Fix more GCC strict-aliasing warnings.
[emacs.git] / src / keyboard.c
blob6a63caa15d36f40c884ad7f407c3638a448b93a2
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, 2009, 2010, 2011 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 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
22 #include <signal.h>
23 #include <stdio.h>
24 #include <setjmp.h>
25 #include "lisp.h"
26 #include "termchar.h"
27 #include "termopts.h"
28 #include "frame.h"
29 #include "termhooks.h"
30 #include "macros.h"
31 #include "keyboard.h"
32 #include "window.h"
33 #include "commands.h"
34 #include "buffer.h"
35 #include "character.h"
36 #include "disptab.h"
37 #include "dispextern.h"
38 #include "syntax.h"
39 #include "intervals.h"
40 #include "keymap.h"
41 #include "blockinput.h"
42 #include "puresize.h"
43 #include "systime.h"
44 #include "atimer.h"
45 #include <errno.h>
47 #ifdef HAVE_GTK_AND_PTHREAD
48 #include <pthread.h>
49 #endif
50 #ifdef MSDOS
51 #include "msdos.h"
52 #include <time.h>
53 #else /* not MSDOS */
54 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
59 #include <sys/types.h>
60 #ifdef HAVE_UNISTD_H
61 #include <unistd.h>
62 #endif
64 #ifdef HAVE_FCNTL_H
65 #include <fcntl.h>
66 #endif
68 /* This is to get the definitions of the XK_ symbols. */
69 #ifdef HAVE_X_WINDOWS
70 #include "xterm.h"
71 #endif
73 #ifdef HAVE_NTGUI
74 #include "w32term.h"
75 #endif /* HAVE_NTGUI */
77 #ifdef HAVE_NS
78 #include "nsterm.h"
79 #endif
81 #ifndef USE_CRT_DLL
82 extern int errno;
83 #endif
85 /* Variables for blockinput.h: */
87 /* Non-zero if interrupt input is blocked right now. */
88 volatile int interrupt_input_blocked;
90 /* Nonzero means an input interrupt has arrived
91 during the current critical section. */
92 int interrupt_input_pending;
94 /* This var should be (interrupt_input_pending || pending_atimers).
95 The QUIT macro checks this instead of interrupt_input_pending and
96 pending_atimers separately, to reduce code size. So, any code that
97 changes interrupt_input_pending or pending_atimers should update
98 this too. */
99 #ifdef SYNC_INPUT
100 int pending_signals;
101 #endif
103 #define KBD_BUFFER_SIZE 4096
105 KBOARD *initial_kboard;
106 KBOARD *current_kboard;
107 KBOARD *all_kboards;
108 int single_kboard;
110 /* Non-nil disable property on a command means
111 do not execute it; call disabled-command-function's value instead. */
112 Lisp_Object Qdisabled, Qdisabled_command_function;
114 #define NUM_RECENT_KEYS (300)
115 int recent_keys_index; /* Index for storing next element into recent_keys */
116 int total_keys; /* Total number of elements stored into recent_keys */
117 Lisp_Object recent_keys; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
119 /* Vector holding the key sequence that invoked the current command.
120 It is reused for each command, and it may be longer than the current
121 sequence; this_command_key_count indicates how many elements
122 actually mean something.
123 It's easier to staticpro a single Lisp_Object than an array. */
124 Lisp_Object this_command_keys;
125 int this_command_key_count;
127 /* 1 after calling Freset_this_command_lengths.
128 Usually it is 0. */
129 int this_command_key_count_reset;
131 /* This vector is used as a buffer to record the events that were actually read
132 by read_key_sequence. */
133 Lisp_Object raw_keybuf;
134 int raw_keybuf_count;
136 /* Non-nil if the present key sequence was obtained by shift translation. */
137 Lisp_Object Vthis_command_keys_shift_translated;
139 #define GROW_RAW_KEYBUF \
140 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
141 raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
143 /* Number of elements of this_command_keys
144 that precede this key sequence. */
145 int this_single_command_key_start;
147 /* Record values of this_command_key_count and echo_length ()
148 before this command was read. */
149 static int before_command_key_count;
150 static int before_command_echo_length;
152 extern int minbuf_level;
154 extern int message_enable_multibyte;
156 /* If non-nil, the function that implements the display of help.
157 It's called with one argument, the help string to display. */
159 Lisp_Object Vshow_help_function;
161 /* Nonzero means do menu prompting. */
163 static int menu_prompting;
165 /* Character to see next line of menu prompt. */
167 static Lisp_Object menu_prompt_more_char;
169 /* For longjmp to where kbd input is being done. */
171 static jmp_buf getcjmp;
173 /* True while doing kbd input. */
174 int waiting_for_input;
176 /* True while displaying for echoing. Delays C-g throwing. */
178 int echoing;
180 /* Non-null means we can start echoing at the next input pause even
181 though there is something in the echo area. */
183 static struct kboard *ok_to_echo_at_next_pause;
185 /* The kboard last echoing, or null for none. Reset to 0 in
186 cancel_echoing. If non-null, and a current echo area message
187 exists, and echo_message_buffer is eq to the current message
188 buffer, we know that the message comes from echo_kboard. */
190 struct kboard *echo_kboard;
192 /* The buffer used for echoing. Set in echo_now, reset in
193 cancel_echoing. */
195 Lisp_Object echo_message_buffer;
197 /* Nonzero means disregard local maps for the menu bar. */
198 static int inhibit_local_menu_bar_menus;
200 /* Nonzero means C-g should cause immediate error-signal. */
201 int immediate_quit;
203 /* The user's hook function for outputting an error message. */
204 Lisp_Object Vcommand_error_function;
206 /* The user's ERASE setting. */
207 Lisp_Object Vtty_erase_char;
209 /* Character to recognize as the help char. */
210 Lisp_Object Vhelp_char;
212 /* List of other event types to recognize as meaning "help". */
213 Lisp_Object Vhelp_event_list;
215 /* Form to execute when help char is typed. */
216 Lisp_Object Vhelp_form;
218 /* Command to run when the help character follows a prefix key. */
219 Lisp_Object Vprefix_help_command;
221 /* List of items that should move to the end of the menu bar. */
222 Lisp_Object Vmenu_bar_final_items;
224 /* Non-nil means show the equivalent key-binding for
225 any M-x command that has one.
226 The value can be a length of time to show the message for.
227 If the value is non-nil and not a number, we wait 2 seconds. */
228 Lisp_Object Vsuggest_key_bindings;
230 /* How long to display an echo-area message when the minibuffer is active.
231 If the value is not a number, such messages don't time out. */
232 Lisp_Object Vminibuffer_message_timeout;
234 /* Character that causes a quit. Normally C-g.
236 If we are running on an ordinary terminal, this must be an ordinary
237 ASCII char, since we want to make it our interrupt character.
239 If we are not running on an ordinary terminal, it still needs to be
240 an ordinary ASCII char. This character needs to be recognized in
241 the input interrupt handler. At this point, the keystroke is
242 represented as a struct input_event, while the desired quit
243 character is specified as a lispy event. The mapping from struct
244 input_events to lispy events cannot run in an interrupt handler,
245 and the reverse mapping is difficult for anything but ASCII
246 keystrokes.
248 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
249 ASCII character. */
250 int quit_char;
252 extern Lisp_Object current_global_map;
253 extern int minibuf_level;
255 /* If non-nil, this is a map that overrides all other local maps. */
256 Lisp_Object Voverriding_local_map;
258 /* If non-nil, Voverriding_local_map applies to the menu bar. */
259 Lisp_Object Voverriding_local_map_menu_flag;
261 /* Keymap that defines special misc events that should
262 be processed immediately at a low level. */
263 Lisp_Object Vspecial_event_map;
265 /* Current depth in recursive edits. */
266 int command_loop_level;
268 /* Total number of times command_loop has read a key sequence. */
269 EMACS_INT num_input_keys;
271 /* Last input event read as a command. */
272 Lisp_Object last_command_event;
274 /* Last input character read as a command, not counting menus
275 reached by the mouse. */
276 Lisp_Object last_nonmenu_event;
278 /* Last input event read for any purpose. */
279 Lisp_Object last_input_event;
281 /* If not Qnil, a list of objects to be read as subsequent command input. */
282 Lisp_Object Vunread_command_events;
284 /* If not Qnil, a list of objects to be read as subsequent command input
285 including input method processing. */
286 Lisp_Object Vunread_input_method_events;
288 /* If not Qnil, a list of objects to be read as subsequent command input
289 but NOT including input method processing. */
290 Lisp_Object Vunread_post_input_method_events;
292 /* If not -1, an event to be read as subsequent command input. */
293 EMACS_INT unread_command_char;
295 /* If not Qnil, this is a switch-frame event which we decided to put
296 off until the end of a key sequence. This should be read as the
297 next command input, after any unread_command_events.
299 read_key_sequence uses this to delay switch-frame events until the
300 end of the key sequence; Fread_char uses it to put off switch-frame
301 events until a non-ASCII event is acceptable as input. */
302 Lisp_Object unread_switch_frame;
304 /* A mask of extra modifier bits to put into every keyboard char. */
305 EMACS_INT extra_keyboard_modifiers;
307 /* Char to use as prefix when a meta character is typed in.
308 This is bound on entry to minibuffer in case ESC is changed there. */
310 Lisp_Object meta_prefix_char;
312 /* Last size recorded for a current buffer which is not a minibuffer. */
313 static int last_non_minibuf_size;
315 /* Number of idle seconds before an auto-save and garbage collection. */
316 static Lisp_Object Vauto_save_timeout;
318 /* Total number of times read_char has returned. */
319 int num_input_events;
321 /* Total number of times read_char has returned, outside of macros. */
322 EMACS_INT num_nonmacro_input_events;
324 /* Auto-save automatically when this many characters have been typed
325 since the last time. */
327 static EMACS_INT auto_save_interval;
329 /* Value of num_nonmacro_input_events as of last auto save. */
331 int last_auto_save;
333 /* The command being executed by the command loop.
334 Commands may set this, and the value set will be copied into
335 current_kboard->Vlast_command instead of the actual command. */
336 Lisp_Object Vthis_command;
338 /* This is like Vthis_command, except that commands never set it. */
339 Lisp_Object real_this_command;
341 /* If the lookup of the command returns a binding, the original
342 command is stored in this-original-command. It is nil otherwise. */
343 Lisp_Object Vthis_original_command;
345 /* The value of point when the last command was started. */
346 int last_point_position;
348 /* The buffer that was current when the last command was started. */
349 Lisp_Object last_point_position_buffer;
351 /* The window that was selected when the last command was started. */
352 Lisp_Object last_point_position_window;
354 /* The frame in which the last input event occurred, or Qmacro if the
355 last event came from a macro. We use this to determine when to
356 generate switch-frame events. This may be cleared by functions
357 like Fselect_frame, to make sure that a switch-frame event is
358 generated by the next character. */
359 Lisp_Object internal_last_event_frame;
361 /* A user-visible version of the above, intended to allow users to
362 figure out where the last event came from, if the event doesn't
363 carry that information itself (i.e. if it was a character). */
364 Lisp_Object Vlast_event_frame;
366 /* The timestamp of the last input event we received from the X server.
367 X Windows wants this for selection ownership. */
368 unsigned long last_event_timestamp;
370 Lisp_Object Qself_insert_command;
371 Lisp_Object Qforward_char;
372 Lisp_Object Qbackward_char;
373 Lisp_Object Qundefined;
374 Lisp_Object Qtimer_event_handler;
376 /* read_key_sequence stores here the command definition of the
377 key sequence that it reads. */
378 Lisp_Object read_key_sequence_cmd;
380 /* Echo unfinished commands after this many seconds of pause. */
381 Lisp_Object Vecho_keystrokes;
383 /* Form to evaluate (if non-nil) when Emacs is started. */
384 Lisp_Object Vtop_level;
386 /* If non-nil, this implements the current input method. */
387 Lisp_Object Vinput_method_function;
388 Lisp_Object Qinput_method_function;
390 /* When we call Vinput_method_function,
391 this holds the echo area message that was just erased. */
392 Lisp_Object Vinput_method_previous_message;
394 /* Non-nil means deactivate the mark at end of this command. */
395 Lisp_Object Vdeactivate_mark;
396 Lisp_Object Qdeactivate_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. */
428 FILE *dribble;
430 /* Nonzero if input is available. */
431 int input_pending;
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 extern Lisp_Object Qremap;
476 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
477 Lisp_Object Qmouse_fixup_help_message;
478 #endif
480 /* Symbols to denote kinds of events. */
481 Lisp_Object Qfunction_key;
482 Lisp_Object Qmouse_click;
483 #if defined (WINDOWSNT)
484 Lisp_Object Qlanguage_change;
485 #endif
486 Lisp_Object Qdrag_n_drop;
487 Lisp_Object Qsave_session;
488 #ifdef HAVE_DBUS
489 Lisp_Object Qdbus_event;
490 #endif
491 Lisp_Object Qconfig_changed_event;
493 /* Lisp_Object Qmouse_movement; - also an event header */
495 /* Properties of event headers. */
496 Lisp_Object Qevent_kind;
497 Lisp_Object Qevent_symbol_elements;
499 /* menu item parts */
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 Qmenu_item;
505 /* An event header symbol HEAD may have a property named
506 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
507 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
508 mask of modifiers applied to it. If present, this is used to help
509 speed up parse_modifiers. */
510 Lisp_Object Qevent_symbol_element_mask;
512 /* An unmodified event header BASE may have a property named
513 Qmodifier_cache, which is an alist mapping modifier masks onto
514 modified versions of BASE. If present, this helps speed up
515 apply_modifiers. */
516 Lisp_Object Qmodifier_cache;
518 /* Symbols to use for parts of windows. */
519 Lisp_Object Qmode_line;
520 Lisp_Object Qvertical_line;
521 Lisp_Object Qvertical_scroll_bar;
522 Lisp_Object Qmenu_bar;
523 extern Lisp_Object Qleft_margin, Qright_margin;
524 extern Lisp_Object Qleft_fringe, Qright_fringe;
525 extern Lisp_Object QCmap;
527 Lisp_Object recursive_edit_unwind (), command_loop ();
528 Lisp_Object Fthis_command_keys ();
529 Lisp_Object Qextended_command_history;
530 EMACS_TIME timer_check ();
532 extern Lisp_Object Vhistory_length, Vtranslation_table_for_input;
534 extern char *x_get_keysym_name ();
536 static void record_menu_key ();
537 static int echo_length ();
539 Lisp_Object Qpolling_period;
541 /* List of absolute timers. Appears in order of next scheduled event. */
542 Lisp_Object Vtimer_list;
544 /* List of idle time timers. Appears in order of next scheduled event. */
545 Lisp_Object Vtimer_idle_list;
547 /* Incremented whenever a timer is run. */
548 int timers_run;
550 extern Lisp_Object Vprint_level, Vprint_length;
552 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
553 happens. */
554 EMACS_TIME *input_available_clear_time;
556 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
557 Default is 1 if INTERRUPT_INPUT is defined. */
558 int interrupt_input;
560 /* Nonzero while interrupts are temporarily deferred during redisplay. */
561 int interrupts_deferred;
563 /* Allow m- file to inhibit use of FIONREAD. */
564 #ifdef BROKEN_FIONREAD
565 #undef FIONREAD
566 #endif
568 /* We are unable to use interrupts if FIONREAD is not available,
569 so flush SIGIO so we won't try. */
570 #if !defined (FIONREAD)
571 #ifdef SIGIO
572 #undef SIGIO
573 #endif
574 #endif
576 /* If we support a window system, turn on the code to poll periodically
577 to detect C-g. It isn't actually used when doing interrupt input. */
578 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
579 #define POLL_FOR_INPUT
580 #endif
582 /* After a command is executed, if point is moved into a region that
583 has specific properties (e.g. composition, display), we adjust
584 point to the boundary of the region. But, if a command sets this
585 variable to non-nil, we suppress this point adjustment. This
586 variable is set to nil before reading a command. */
588 Lisp_Object Vdisable_point_adjustment;
590 /* If non-nil, always disable point adjustment. */
592 Lisp_Object Vglobal_disable_point_adjustment;
594 /* The time when Emacs started being idle. */
596 static EMACS_TIME timer_idleness_start_time;
598 /* After Emacs stops being idle, this saves the last value
599 of timer_idleness_start_time from when it was idle. */
601 static EMACS_TIME timer_last_idleness_start_time;
603 /* If non-nil, events produced by disabled menu items and tool-bar
604 buttons are not ignored. Help functions bind this to allow help on
605 those items and buttons. */
606 Lisp_Object Venable_disabled_menus_and_buttons;
609 /* Global variable declarations. */
611 /* Flags for readable_events. */
612 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
613 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
614 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
616 /* Function for init_keyboard to call with no args (if nonzero). */
617 void (*keyboard_init_hook) ();
619 static int read_avail_input P_ ((int));
620 static void get_input_pending P_ ((int *, int));
621 static int readable_events P_ ((int));
622 static Lisp_Object read_char_x_menu_prompt P_ ((int, Lisp_Object *,
623 Lisp_Object, int *));
624 static Lisp_Object read_char_x_menu_prompt ();
625 static Lisp_Object read_char_minibuf_menu_prompt P_ ((int, int,
626 Lisp_Object *));
627 static Lisp_Object make_lispy_event P_ ((struct input_event *));
628 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
629 static Lisp_Object make_lispy_movement P_ ((struct frame *, Lisp_Object,
630 enum scroll_bar_part,
631 Lisp_Object, Lisp_Object,
632 unsigned long));
633 #endif
634 static Lisp_Object modify_event_symbol P_ ((int, unsigned, Lisp_Object,
635 Lisp_Object, char **,
636 Lisp_Object *, unsigned));
637 static Lisp_Object make_lispy_switch_frame P_ ((Lisp_Object));
638 static void save_getcjmp P_ ((jmp_buf));
639 static void save_getcjmp ();
640 static void restore_getcjmp P_ ((jmp_buf));
641 static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
642 static void clear_event P_ ((struct input_event *));
643 static Lisp_Object restore_kboard_configuration P_ ((Lisp_Object));
644 static SIGTYPE interrupt_signal P_ ((int signalnum));
645 #ifdef SIGIO
646 static SIGTYPE input_available_signal (int signo);
647 #endif
648 static void handle_interrupt P_ ((void));
649 static void timer_start_idle P_ ((void));
650 static void timer_stop_idle P_ ((void));
651 static void timer_resume_idle P_ ((void));
652 static SIGTYPE handle_user_signal P_ ((int));
653 static char *find_user_signal_name P_ ((int));
654 static int store_user_signal_events P_ ((void));
656 /* Nonzero means don't try to suspend even if the operating system seems
657 to support it. */
658 static int cannot_suspend;
660 extern Lisp_Object Qidentity, Qonly;
662 /* Install the string STR as the beginning of the string of echoing,
663 so that it serves as a prompt for the next character.
664 Also start echoing. */
666 void
667 echo_prompt (str)
668 Lisp_Object str;
670 current_kboard->echo_string = str;
671 current_kboard->echo_after_prompt = SCHARS (str);
672 echo_now ();
675 /* Add C to the echo string, if echoing is going on.
676 C can be a character, which is printed prettily ("M-C-x" and all that
677 jazz), or a symbol, whose name is printed. */
679 void
680 echo_char (c)
681 Lisp_Object c;
683 if (current_kboard->immediate_echo)
685 int size = KEY_DESCRIPTION_SIZE + 100;
686 char *buffer = (char *) alloca (size);
687 char *ptr = buffer;
688 Lisp_Object echo_string;
690 echo_string = current_kboard->echo_string;
692 /* If someone has passed us a composite event, use its head symbol. */
693 c = EVENT_HEAD (c);
695 if (INTEGERP (c))
697 ptr = push_key_description (XINT (c), ptr, 1);
699 else if (SYMBOLP (c))
701 Lisp_Object name = SYMBOL_NAME (c);
702 int nbytes = SBYTES (name);
704 if (size - (ptr - buffer) < nbytes)
706 int offset = ptr - buffer;
707 size = max (2 * size, size + nbytes);
708 buffer = (char *) alloca (size);
709 ptr = buffer + offset;
712 ptr += copy_text (SDATA (name), ptr, nbytes,
713 STRING_MULTIBYTE (name), 1);
716 if ((NILP (echo_string) || SCHARS (echo_string) == 0)
717 && help_char_p (c))
719 const char *text = " (Type ? for further options)";
720 int len = strlen (text);
722 if (size - (ptr - buffer) < len)
724 int offset = ptr - buffer;
725 size += len;
726 buffer = (char *) alloca (size);
727 ptr = buffer + offset;
730 bcopy (text, ptr, len);
731 ptr += len;
734 /* Replace a dash from echo_dash with a space, otherwise
735 add a space at the end as a separator between keys. */
736 if (STRINGP (echo_string)
737 && SCHARS (echo_string) > 1)
739 Lisp_Object last_char, prev_char, idx;
741 idx = make_number (SCHARS (echo_string) - 2);
742 prev_char = Faref (echo_string, idx);
744 idx = make_number (SCHARS (echo_string) - 1);
745 last_char = Faref (echo_string, idx);
747 /* We test PREV_CHAR to make sure this isn't the echoing
748 of a minus-sign. */
749 if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
750 Faset (echo_string, idx, make_number (' '));
751 else
752 echo_string = concat2 (echo_string, build_string (" "));
754 else if (STRINGP (echo_string))
755 echo_string = concat2 (echo_string, build_string (" "));
757 current_kboard->echo_string
758 = concat2 (echo_string, make_string (buffer, ptr - buffer));
760 echo_now ();
764 /* Temporarily add a dash to the end of the echo string if it's not
765 empty, so that it serves as a mini-prompt for the very next character. */
767 void
768 echo_dash ()
770 /* Do nothing if not echoing at all. */
771 if (NILP (current_kboard->echo_string))
772 return;
774 if (!current_kboard->immediate_echo
775 && SCHARS (current_kboard->echo_string) == 0)
776 return;
778 /* Do nothing if we just printed a prompt. */
779 if (current_kboard->echo_after_prompt
780 == SCHARS (current_kboard->echo_string))
781 return;
783 /* Do nothing if we have already put a dash at the end. */
784 if (SCHARS (current_kboard->echo_string) > 1)
786 Lisp_Object last_char, prev_char, idx;
788 idx = make_number (SCHARS (current_kboard->echo_string) - 2);
789 prev_char = Faref (current_kboard->echo_string, idx);
791 idx = make_number (SCHARS (current_kboard->echo_string) - 1);
792 last_char = Faref (current_kboard->echo_string, idx);
794 if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
795 return;
798 /* Put a dash at the end of the buffer temporarily,
799 but make it go away when the next character is added. */
800 current_kboard->echo_string = concat2 (current_kboard->echo_string,
801 build_string ("-"));
802 echo_now ();
805 /* Display the current echo string, and begin echoing if not already
806 doing so. */
808 void
809 echo_now ()
811 if (!current_kboard->immediate_echo)
813 int i;
814 current_kboard->immediate_echo = 1;
816 for (i = 0; i < this_command_key_count; i++)
818 Lisp_Object c;
820 /* Set before_command_echo_length to the value that would
821 have been saved before the start of this subcommand in
822 command_loop_1, if we had already been echoing then. */
823 if (i == this_single_command_key_start)
824 before_command_echo_length = echo_length ();
826 c = XVECTOR (this_command_keys)->contents[i];
827 if (! (EVENT_HAS_PARAMETERS (c)
828 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
829 echo_char (c);
832 /* Set before_command_echo_length to the value that would
833 have been saved before the start of this subcommand in
834 command_loop_1, if we had already been echoing then. */
835 if (this_command_key_count == this_single_command_key_start)
836 before_command_echo_length = echo_length ();
838 /* Put a dash at the end to invite the user to type more. */
839 echo_dash ();
842 echoing = 1;
843 message3_nolog (current_kboard->echo_string,
844 SBYTES (current_kboard->echo_string),
845 STRING_MULTIBYTE (current_kboard->echo_string));
846 echoing = 0;
848 /* Record in what buffer we echoed, and from which kboard. */
849 echo_message_buffer = echo_area_buffer[0];
850 echo_kboard = current_kboard;
852 if (waiting_for_input && !NILP (Vquit_flag))
853 quit_throw_to_read_char ();
856 /* Turn off echoing, for the start of a new command. */
858 void
859 cancel_echoing ()
861 current_kboard->immediate_echo = 0;
862 current_kboard->echo_after_prompt = -1;
863 current_kboard->echo_string = Qnil;
864 ok_to_echo_at_next_pause = NULL;
865 echo_kboard = NULL;
866 echo_message_buffer = Qnil;
869 /* Return the length of the current echo string. */
871 static int
872 echo_length ()
874 return (STRINGP (current_kboard->echo_string)
875 ? SCHARS (current_kboard->echo_string)
876 : 0);
879 /* Truncate the current echo message to its first LEN chars.
880 This and echo_char get used by read_key_sequence when the user
881 switches frames while entering a key sequence. */
883 static void
884 echo_truncate (nchars)
885 int nchars;
887 if (STRINGP (current_kboard->echo_string))
888 current_kboard->echo_string
889 = Fsubstring (current_kboard->echo_string,
890 make_number (0), make_number (nchars));
891 truncate_echo_area (nchars);
895 /* Functions for manipulating this_command_keys. */
896 static void
897 add_command_key (key)
898 Lisp_Object key;
900 #if 0 /* Not needed after we made Freset_this_command_lengths
901 do the job immediately. */
902 /* If reset-this-command-length was called recently, obey it now.
903 See the doc string of that function for an explanation of why. */
904 if (before_command_restore_flag)
906 this_command_key_count = before_command_key_count_1;
907 if (this_command_key_count < this_single_command_key_start)
908 this_single_command_key_start = this_command_key_count;
909 echo_truncate (before_command_echo_length_1);
910 before_command_restore_flag = 0;
912 #endif
914 if (this_command_key_count >= ASIZE (this_command_keys))
915 this_command_keys = larger_vector (this_command_keys,
916 2 * ASIZE (this_command_keys),
917 Qnil);
919 ASET (this_command_keys, this_command_key_count, key);
920 ++this_command_key_count;
924 Lisp_Object
925 recursive_edit_1 ()
927 int count = SPECPDL_INDEX ();
928 Lisp_Object val;
930 if (command_loop_level > 0)
932 specbind (Qstandard_output, Qt);
933 specbind (Qstandard_input, Qt);
936 #ifdef HAVE_WINDOW_SYSTEM
937 /* The command loop has started an hourglass timer, so we have to
938 cancel it here, otherwise it will fire because the recursive edit
939 can take some time. Do not check for display_hourglass_p here,
940 because it could already be nil. */
941 cancel_hourglass ();
942 #endif
944 /* This function may have been called from a debugger called from
945 within redisplay, for instance by Edebugging a function called
946 from fontification-functions. We want to allow redisplay in
947 the debugging session.
949 The recursive edit is left with a `(throw exit ...)'. The `exit'
950 tag is not caught anywhere in redisplay, i.e. when we leave the
951 recursive edit, the original redisplay leading to the recursive
952 edit will be unwound. The outcome should therefore be safe. */
953 specbind (Qinhibit_redisplay, Qnil);
954 redisplaying_p = 0;
956 val = command_loop ();
957 if (EQ (val, Qt))
958 Fsignal (Qquit, Qnil);
959 /* Handle throw from read_minibuf when using minibuffer
960 while it's active but we're in another window. */
961 if (STRINGP (val))
962 xsignal1 (Qerror, val);
964 return unbind_to (count, Qnil);
967 /* When an auto-save happens, record the "time", and don't do again soon. */
969 void
970 record_auto_save ()
972 last_auto_save = num_nonmacro_input_events;
975 /* Make an auto save happen as soon as possible at command level. */
977 void
978 force_auto_save_soon ()
980 last_auto_save = - auto_save_interval - 1;
982 record_asynch_buffer_change ();
985 DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
986 doc: /* Invoke the editor command loop recursively.
987 To get out of the recursive edit, a command can do `(throw 'exit nil)';
988 that tells this function to return.
989 Alternatively, `(throw 'exit t)' makes this function signal an error.
990 This function is called by the editor initialization to begin editing. */)
993 int count = SPECPDL_INDEX ();
994 Lisp_Object buffer;
996 /* If we enter while input is blocked, don't lock up here.
997 This may happen through the debugger during redisplay. */
998 if (INPUT_BLOCKED_P)
999 return Qnil;
1001 command_loop_level++;
1002 update_mode_lines = 1;
1004 if (command_loop_level
1005 && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
1006 buffer = Fcurrent_buffer ();
1007 else
1008 buffer = Qnil;
1010 /* If we leave recursive_edit_1 below with a `throw' for instance,
1011 like it is done in the splash screen display, we have to
1012 make sure that we restore single_kboard as command_loop_1
1013 would have done if it were left normally. */
1014 if (command_loop_level > 0)
1015 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
1016 record_unwind_protect (recursive_edit_unwind, buffer);
1018 recursive_edit_1 ();
1019 return unbind_to (count, Qnil);
1022 Lisp_Object
1023 recursive_edit_unwind (buffer)
1024 Lisp_Object buffer;
1026 if (BUFFERP (buffer))
1027 Fset_buffer (buffer);
1029 command_loop_level--;
1030 update_mode_lines = 1;
1031 return Qnil;
1035 #if 0 /* These two functions are now replaced with
1036 temporarily_switch_to_single_kboard. */
1037 static void
1038 any_kboard_state ()
1040 #if 0 /* Theory: if there's anything in Vunread_command_events,
1041 it will right away be read by read_key_sequence,
1042 and then if we do switch KBOARDS, it will go into the side
1043 queue then. So we don't need to do anything special here -- rms. */
1044 if (CONSP (Vunread_command_events))
1046 current_kboard->kbd_queue
1047 = nconc2 (Vunread_command_events, current_kboard->kbd_queue);
1048 current_kboard->kbd_queue_has_data = 1;
1050 Vunread_command_events = Qnil;
1051 #endif
1052 single_kboard = 0;
1055 /* Switch to the single-kboard state, making current_kboard
1056 the only KBOARD from which further input is accepted. */
1058 void
1059 single_kboard_state ()
1061 single_kboard = 1;
1063 #endif
1065 /* If we're in single_kboard state for kboard KBOARD,
1066 get out of it. */
1068 void
1069 not_single_kboard_state (kboard)
1070 KBOARD *kboard;
1072 if (kboard == current_kboard)
1073 single_kboard = 0;
1076 /* Maintain a stack of kboards, so other parts of Emacs
1077 can switch temporarily to the kboard of a given frame
1078 and then revert to the previous status. */
1080 struct kboard_stack
1082 KBOARD *kboard;
1083 struct kboard_stack *next;
1086 static struct kboard_stack *kboard_stack;
1088 void
1089 push_kboard (k)
1090 struct kboard *k;
1092 struct kboard_stack *p
1093 = (struct kboard_stack *) xmalloc (sizeof (struct kboard_stack));
1095 p->next = kboard_stack;
1096 p->kboard = current_kboard;
1097 kboard_stack = p;
1099 current_kboard = k;
1102 void
1103 pop_kboard ()
1105 struct terminal *t;
1106 struct kboard_stack *p = kboard_stack;
1107 int found = 0;
1108 for (t = terminal_list; t; t = t->next_terminal)
1110 if (t->kboard == p->kboard)
1112 current_kboard = p->kboard;
1113 found = 1;
1114 break;
1117 if (!found)
1119 /* The terminal we remembered has been deleted. */
1120 current_kboard = FRAME_KBOARD (SELECTED_FRAME ());
1121 single_kboard = 0;
1123 kboard_stack = p->next;
1124 xfree (p);
1127 /* Switch to single_kboard mode, making current_kboard the only KBOARD
1128 from which further input is accepted. If F is non-nil, set its
1129 KBOARD as the current keyboard.
1131 This function uses record_unwind_protect to return to the previous
1132 state later.
1134 If Emacs is already in single_kboard mode, and F's keyboard is
1135 locked, then this function will throw an errow. */
1137 void
1138 temporarily_switch_to_single_kboard (f)
1139 struct frame *f;
1141 int was_locked = single_kboard;
1142 if (was_locked)
1144 if (f != NULL && FRAME_KBOARD (f) != current_kboard)
1145 /* We can not switch keyboards while in single_kboard mode.
1146 In rare cases, Lisp code may call `recursive-edit' (or
1147 `read-minibuffer' or `y-or-n-p') after it switched to a
1148 locked frame. For example, this is likely to happen
1149 when server.el connects to a new terminal while Emacs is in
1150 single_kboard mode. It is best to throw an error instead
1151 of presenting the user with a frozen screen. */
1152 error ("Terminal %d is locked, cannot read from it",
1153 FRAME_TERMINAL (f)->id);
1154 else
1155 /* This call is unnecessary, but helps
1156 `restore_kboard_configuration' discover if somebody changed
1157 `current_kboard' behind our back. */
1158 push_kboard (current_kboard);
1160 else if (f != NULL)
1161 current_kboard = FRAME_KBOARD (f);
1162 single_kboard = 1;
1163 record_unwind_protect (restore_kboard_configuration,
1164 (was_locked ? Qt : Qnil));
1167 #if 0 /* This function is not needed anymore. */
1168 void
1169 record_single_kboard_state ()
1171 if (single_kboard)
1172 push_kboard (current_kboard);
1173 record_unwind_protect (restore_kboard_configuration,
1174 (single_kboard ? Qt : Qnil));
1176 #endif
1178 static Lisp_Object
1179 restore_kboard_configuration (was_locked)
1180 Lisp_Object was_locked;
1182 if (NILP (was_locked))
1183 single_kboard = 0;
1184 else
1186 struct kboard *prev = current_kboard;
1187 single_kboard = 1;
1188 pop_kboard ();
1189 /* The pop should not change the kboard. */
1190 if (single_kboard && current_kboard != prev)
1191 abort ();
1193 return Qnil;
1197 /* Handle errors that are not handled at inner levels
1198 by printing an error message and returning to the editor command loop. */
1200 Lisp_Object
1201 cmd_error (data)
1202 Lisp_Object data;
1204 Lisp_Object old_level, old_length;
1205 char macroerror[50];
1207 #ifdef HAVE_WINDOW_SYSTEM
1208 if (display_hourglass_p)
1209 cancel_hourglass ();
1210 #endif
1212 if (!NILP (executing_kbd_macro))
1214 if (executing_kbd_macro_iterations == 1)
1215 sprintf (macroerror, "After 1 kbd macro iteration: ");
1216 else
1217 sprintf (macroerror, "After %d kbd macro iterations: ",
1218 executing_kbd_macro_iterations);
1220 else
1221 *macroerror = 0;
1223 Vstandard_output = Qt;
1224 Vstandard_input = Qt;
1225 Vexecuting_kbd_macro = Qnil;
1226 executing_kbd_macro = Qnil;
1227 current_kboard->Vprefix_arg = Qnil;
1228 current_kboard->Vlast_prefix_arg = Qnil;
1229 cancel_echoing ();
1231 /* Avoid unquittable loop if data contains a circular list. */
1232 old_level = Vprint_level;
1233 old_length = Vprint_length;
1234 XSETFASTINT (Vprint_level, 10);
1235 XSETFASTINT (Vprint_length, 10);
1236 cmd_error_internal (data, macroerror);
1237 Vprint_level = old_level;
1238 Vprint_length = old_length;
1240 Vquit_flag = Qnil;
1242 Vinhibit_quit = Qnil;
1243 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1244 if (command_loop_level == 0 && minibuf_level == 0)
1245 any_kboard_state ();
1246 #endif
1248 return make_number (0);
1251 /* Take actions on handling an error. DATA is the data that describes
1252 the error.
1254 CONTEXT is a C-string containing ASCII characters only which
1255 describes the context in which the error happened. If we need to
1256 generalize CONTEXT to allow multibyte characters, make it a Lisp
1257 string. */
1259 void
1260 cmd_error_internal (data, context)
1261 Lisp_Object data;
1262 char *context;
1264 struct frame *sf = SELECTED_FRAME ();
1266 /* The immediate context is not interesting for Quits,
1267 since they are asyncronous. */
1268 if (EQ (XCAR (data), Qquit))
1269 Vsignaling_function = Qnil;
1271 Vquit_flag = Qnil;
1272 Vinhibit_quit = Qt;
1274 /* Use user's specified output function if any. */
1275 if (!NILP (Vcommand_error_function))
1276 call3 (Vcommand_error_function, data,
1277 context ? build_string (context) : empty_unibyte_string,
1278 Vsignaling_function);
1279 /* If the window system or terminal frame hasn't been initialized
1280 yet, or we're not interactive, write the message to stderr and exit. */
1281 else if (!sf->glyphs_initialized_p
1282 /* The initial frame is a special non-displaying frame. It
1283 will be current in daemon mode when there are no frames
1284 to display, and in non-daemon mode before the real frame
1285 has finished initializing. If an error is thrown in the
1286 latter case while creating the frame, then the frame
1287 will never be displayed, so the safest thing to do is
1288 write to stderr and quit. In daemon mode, there are
1289 many other potential errors that do not prevent frames
1290 from being created, so continuing as normal is better in
1291 that case. */
1292 || (!IS_DAEMON && FRAME_INITIAL_P (sf))
1293 || noninteractive)
1295 print_error_message (data, Qexternal_debugging_output,
1296 context, Vsignaling_function);
1297 Fterpri (Qexternal_debugging_output);
1298 Fkill_emacs (make_number (-1));
1300 else
1302 clear_message (1, 0);
1303 Fdiscard_input ();
1304 message_log_maybe_newline ();
1305 bitch_at_user ();
1307 print_error_message (data, Qt, context, Vsignaling_function);
1310 Vsignaling_function = Qnil;
1313 Lisp_Object command_loop_1 ();
1314 Lisp_Object command_loop_2 ();
1315 Lisp_Object top_level_1 ();
1317 /* Entry to editor-command-loop.
1318 This level has the catches for exiting/returning to editor command loop.
1319 It returns nil to exit recursive edit, t to abort it. */
1321 Lisp_Object
1322 command_loop ()
1324 if (command_loop_level > 0 || minibuf_level > 0)
1326 Lisp_Object val;
1327 val = internal_catch (Qexit, command_loop_2, Qnil);
1328 executing_kbd_macro = Qnil;
1329 return val;
1331 else
1332 while (1)
1334 internal_catch (Qtop_level, top_level_1, Qnil);
1335 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1336 /* Reset single_kboard in case top-level set it while
1337 evaluating an -f option, or we are stuck there for some
1338 other reason. */
1339 any_kboard_state ();
1340 #endif
1341 internal_catch (Qtop_level, command_loop_2, Qnil);
1342 executing_kbd_macro = Qnil;
1344 /* End of file in -batch run causes exit here. */
1345 if (noninteractive)
1346 Fkill_emacs (Qt);
1350 /* Here we catch errors in execution of commands within the
1351 editing loop, and reenter the editing loop.
1352 When there is an error, cmd_error runs and returns a non-nil
1353 value to us. A value of nil means that command_loop_1 itself
1354 returned due to end of file (or end of kbd macro). */
1356 Lisp_Object
1357 command_loop_2 ()
1359 register Lisp_Object val;
1362 val = internal_condition_case (command_loop_1, Qerror, cmd_error);
1363 while (!NILP (val));
1365 return Qnil;
1368 Lisp_Object
1369 top_level_2 ()
1371 return Feval (Vtop_level);
1374 Lisp_Object
1375 top_level_1 ()
1377 /* On entry to the outer level, run the startup file */
1378 if (!NILP (Vtop_level))
1379 internal_condition_case (top_level_2, Qerror, cmd_error);
1380 else if (!NILP (Vpurify_flag))
1381 message ("Bare impure Emacs (standard Lisp code not loaded)");
1382 else
1383 message ("Bare Emacs (standard Lisp code not loaded)");
1384 return Qnil;
1387 DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
1388 doc: /* Exit all recursive editing levels.
1389 This also exits all active minibuffers. */)
1392 #ifdef HAVE_WINDOW_SYSTEM
1393 if (display_hourglass_p)
1394 cancel_hourglass ();
1395 #endif
1397 /* Unblock input if we enter with input blocked. This may happen if
1398 redisplay traps e.g. during tool-bar update with input blocked. */
1399 while (INPUT_BLOCKED_P)
1400 UNBLOCK_INPUT;
1402 return Fthrow (Qtop_level, Qnil);
1405 DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
1406 doc: /* Exit from the innermost recursive edit or minibuffer. */)
1409 if (command_loop_level > 0 || minibuf_level > 0)
1410 Fthrow (Qexit, Qnil);
1412 error ("No recursive edit is in progress");
1413 return Qnil;
1416 DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
1417 doc: /* Abort the command that requested this recursive edit or minibuffer input. */)
1420 if (command_loop_level > 0 || minibuf_level > 0)
1421 Fthrow (Qexit, Qt);
1423 error ("No recursive edit is in progress");
1424 return Qnil;
1427 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1429 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1430 of this function. */
1432 static Lisp_Object
1433 tracking_off (old_value)
1434 Lisp_Object old_value;
1436 do_mouse_tracking = old_value;
1437 if (NILP (old_value))
1439 /* Redisplay may have been preempted because there was input
1440 available, and it assumes it will be called again after the
1441 input has been processed. If the only input available was
1442 the sort that we have just disabled, then we need to call
1443 redisplay. */
1444 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW))
1446 redisplay_preserve_echo_area (6);
1447 get_input_pending (&input_pending,
1448 READABLE_EVENTS_DO_TIMERS_NOW);
1451 return Qnil;
1454 DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
1455 doc: /* Evaluate BODY with mouse movement events enabled.
1456 Within a `track-mouse' form, mouse motion generates input events that
1457 you can read with `read-event'.
1458 Normally, mouse motion is ignored.
1459 usage: (track-mouse BODY...) */)
1460 (args)
1461 Lisp_Object args;
1463 int count = SPECPDL_INDEX ();
1464 Lisp_Object val;
1466 record_unwind_protect (tracking_off, do_mouse_tracking);
1468 do_mouse_tracking = Qt;
1470 val = Fprogn (args);
1471 return unbind_to (count, val);
1474 /* If mouse has moved on some frame, return one of those frames.
1476 Return 0 otherwise.
1478 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1479 after resizing the tool-bar window. */
1481 int ignore_mouse_drag_p;
1483 static FRAME_PTR
1484 some_mouse_moved ()
1486 Lisp_Object tail, frame;
1488 if (ignore_mouse_drag_p)
1490 /* ignore_mouse_drag_p = 0; */
1491 return 0;
1494 FOR_EACH_FRAME (tail, frame)
1496 if (XFRAME (frame)->mouse_moved)
1497 return XFRAME (frame);
1500 return 0;
1503 #endif /* HAVE_MOUSE || HAVE_GPM */
1505 /* This is the actual command reading loop,
1506 sans error-handling encapsulation. */
1508 static int read_key_sequence P_ ((Lisp_Object *, int, Lisp_Object,
1509 int, int, int));
1510 void safe_run_hooks P_ ((Lisp_Object));
1511 static void adjust_point_for_property P_ ((int, int));
1513 /* Cancel hourglass from protect_unwind.
1514 ARG is not used. */
1515 #ifdef HAVE_WINDOW_SYSTEM
1516 static Lisp_Object
1517 cancel_hourglass_unwind (arg)
1518 Lisp_Object arg;
1520 cancel_hourglass ();
1521 return Qnil;
1523 #endif
1525 extern int nonundocount; /* Declared in cmds.c. */
1527 Lisp_Object
1528 command_loop_1 ()
1530 Lisp_Object cmd;
1531 int lose;
1532 Lisp_Object keybuf[30];
1533 int i;
1534 int prev_modiff = 0;
1535 struct buffer *prev_buffer = NULL;
1536 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1537 int was_locked = single_kboard;
1538 #endif
1539 int already_adjusted = 0;
1541 current_kboard->Vprefix_arg = Qnil;
1542 current_kboard->Vlast_prefix_arg = Qnil;
1543 Vdeactivate_mark = Qnil;
1544 waiting_for_input = 0;
1545 cancel_echoing ();
1547 this_command_key_count = 0;
1548 this_command_key_count_reset = 0;
1549 this_single_command_key_start = 0;
1551 if (NILP (Vmemory_full))
1553 /* Make sure this hook runs after commands that get errors and
1554 throw to top level. */
1555 /* Note that the value cell will never directly contain nil
1556 if the symbol is a local variable. */
1557 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1558 safe_run_hooks (Qpost_command_hook);
1560 /* If displaying a message, resize the echo area window to fit
1561 that message's size exactly. */
1562 if (!NILP (echo_area_buffer[0]))
1563 resize_echo_area_exactly ();
1565 if (!NILP (Vdeferred_action_list))
1566 safe_run_hooks (Qdeferred_action_function);
1569 /* Do this after running Vpost_command_hook, for consistency. */
1570 current_kboard->Vlast_command = Vthis_command;
1571 current_kboard->Vreal_last_command = real_this_command;
1572 if (!CONSP (last_command_event))
1573 current_kboard->Vlast_repeatable_command = real_this_command;
1575 while (1)
1577 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1578 Fkill_emacs (Qnil);
1580 /* Make sure the current window's buffer is selected. */
1581 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1582 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1584 /* Display any malloc warning that just came out. Use while because
1585 displaying one warning can cause another. */
1587 while (pending_malloc_warning)
1588 display_malloc_warning ();
1590 Vdeactivate_mark = Qnil;
1592 /* If minibuffer on and echo area in use,
1593 wait a short time and redraw minibuffer. */
1595 if (minibuf_level
1596 && !NILP (echo_area_buffer[0])
1597 && EQ (minibuf_window, echo_area_window)
1598 && NUMBERP (Vminibuffer_message_timeout))
1600 /* Bind inhibit-quit to t so that C-g gets read in
1601 rather than quitting back to the minibuffer. */
1602 int count = SPECPDL_INDEX ();
1603 specbind (Qinhibit_quit, Qt);
1605 sit_for (Vminibuffer_message_timeout, 0, 2);
1607 /* Clear the echo area. */
1608 message2 (0, 0, 0);
1609 safe_run_hooks (Qecho_area_clear_hook);
1611 unbind_to (count, Qnil);
1613 /* If a C-g came in before, treat it as input now. */
1614 if (!NILP (Vquit_flag))
1616 Vquit_flag = Qnil;
1617 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
1621 #if 0
1622 /* Select the frame that the last event came from. Usually,
1623 switch-frame events will take care of this, but if some lisp
1624 code swallows a switch-frame event, we'll fix things up here.
1625 Is this a good idea? */
1626 if (FRAMEP (internal_last_event_frame)
1627 && !EQ (internal_last_event_frame, selected_frame))
1628 Fselect_frame (internal_last_event_frame, Qnil);
1629 #endif
1630 /* If it has changed current-menubar from previous value,
1631 really recompute the menubar from the value. */
1632 if (! NILP (Vlucid_menu_bar_dirty_flag)
1633 && !NILP (Ffboundp (Qrecompute_lucid_menubar)))
1634 call0 (Qrecompute_lucid_menubar);
1636 before_command_key_count = this_command_key_count;
1637 before_command_echo_length = echo_length ();
1639 Vthis_command = Qnil;
1640 real_this_command = Qnil;
1641 Vthis_original_command = Qnil;
1642 Vthis_command_keys_shift_translated = Qnil;
1644 /* Read next key sequence; i gets its length. */
1645 i = read_key_sequence (keybuf, sizeof keybuf / sizeof keybuf[0],
1646 Qnil, 0, 1, 1);
1648 /* A filter may have run while we were reading the input. */
1649 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1650 Fkill_emacs (Qnil);
1651 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1652 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1654 ++num_input_keys;
1656 /* Now we have read a key sequence of length I,
1657 or else I is 0 and we found end of file. */
1659 if (i == 0) /* End of file -- happens only in */
1660 return Qnil; /* a kbd macro, at the end. */
1661 /* -1 means read_key_sequence got a menu that was rejected.
1662 Just loop around and read another command. */
1663 if (i == -1)
1665 cancel_echoing ();
1666 this_command_key_count = 0;
1667 this_command_key_count_reset = 0;
1668 this_single_command_key_start = 0;
1669 goto finalize;
1672 last_command_event = keybuf[i - 1];
1674 /* If the previous command tried to force a specific window-start,
1675 forget about that, in case this command moves point far away
1676 from that position. But also throw away beg_unchanged and
1677 end_unchanged information in that case, so that redisplay will
1678 update the whole window properly. */
1679 if (!NILP (XWINDOW (selected_window)->force_start))
1681 struct buffer *b;
1682 XWINDOW (selected_window)->force_start = Qnil;
1683 b = XBUFFER (XWINDOW (selected_window)->buffer);
1684 BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
1687 cmd = read_key_sequence_cmd;
1688 if (!NILP (Vexecuting_kbd_macro))
1690 if (!NILP (Vquit_flag))
1692 Vexecuting_kbd_macro = Qt;
1693 QUIT; /* Make some noise. */
1694 /* Will return since macro now empty. */
1698 /* Do redisplay processing after this command except in special
1699 cases identified below. */
1700 prev_buffer = current_buffer;
1701 prev_modiff = MODIFF;
1702 last_point_position = PT;
1703 last_point_position_window = selected_window;
1704 XSETBUFFER (last_point_position_buffer, prev_buffer);
1706 /* By default, we adjust point to a boundary of a region that
1707 has such a property that should be treated intangible
1708 (e.g. composition, display). But, some commands will set
1709 this variable differently. */
1710 Vdisable_point_adjustment = Qnil;
1712 /* Process filters and timers may have messed with deactivate-mark.
1713 reset it before we execute the command. */
1714 Vdeactivate_mark = Qnil;
1716 /* Remap command through active keymaps */
1717 Vthis_original_command = cmd;
1718 if (SYMBOLP (cmd))
1720 Lisp_Object cmd1;
1721 if (cmd1 = Fcommand_remapping (cmd, Qnil, Qnil), !NILP (cmd1))
1722 cmd = cmd1;
1725 /* Execute the command. */
1727 Vthis_command = cmd;
1728 real_this_command = cmd;
1729 /* Note that the value cell will never directly contain nil
1730 if the symbol is a local variable. */
1731 if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
1732 safe_run_hooks (Qpre_command_hook);
1734 already_adjusted = 0;
1736 if (NILP (Vthis_command))
1738 /* nil means key is undefined. */
1739 Lisp_Object keys = Fvector (i, keybuf);
1740 keys = Fkey_description (keys, Qnil);
1741 bitch_at_user ();
1742 message_with_string ("%s is undefined", keys, 0);
1743 current_kboard->defining_kbd_macro = Qnil;
1744 update_mode_lines = 1;
1745 current_kboard->Vprefix_arg = Qnil;
1747 else
1749 if (NILP (current_kboard->Vprefix_arg))
1751 /* In case we jump to directly_done. */
1752 Vcurrent_prefix_arg = current_kboard->Vprefix_arg;
1754 /* Recognize some common commands in common situations and
1755 do them directly. */
1756 if (EQ (Vthis_command, Qforward_char) && PT < ZV
1757 && NILP (Vthis_command_keys_shift_translated)
1758 && !CONSP (Vtransient_mark_mode))
1760 struct Lisp_Char_Table *dp
1761 = window_display_table (XWINDOW (selected_window));
1762 lose = FETCH_CHAR (PT_BYTE);
1763 SET_PT (PT + 1);
1764 if (! NILP (Vpost_command_hook))
1765 /* Put this before calling adjust_point_for_property
1766 so it will only get called once in any case. */
1767 goto directly_done;
1768 if (current_buffer == prev_buffer
1769 && last_point_position != PT
1770 && NILP (Vdisable_point_adjustment)
1771 && NILP (Vglobal_disable_point_adjustment))
1772 adjust_point_for_property (last_point_position, 0);
1773 already_adjusted = 1;
1774 if (PT == last_point_position + 1
1775 && (dp
1776 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1777 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1778 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1779 && (lose >= 0x20 && lose < 0x7f)))
1780 : (lose >= 0x20 && lose < 0x7f))
1781 /* To extract the case of continuation on
1782 wide-column characters. */
1783 && ASCII_BYTE_P (lose)
1784 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1785 >= MODIFF)
1786 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1787 >= OVERLAY_MODIFF)
1788 && (XFASTINT (XWINDOW (selected_window)->last_point)
1789 == PT - 1)
1790 && !windows_or_buffers_changed
1791 && EQ (current_buffer->selective_display, Qnil)
1792 && !detect_input_pending ()
1793 && NILP (XWINDOW (selected_window)->column_number_displayed)
1794 && NILP (Vexecuting_kbd_macro))
1795 direct_output_forward_char (1);
1796 goto directly_done;
1798 else if (EQ (Vthis_command, Qbackward_char) && PT > BEGV
1799 && NILP (Vthis_command_keys_shift_translated)
1800 && !CONSP (Vtransient_mark_mode))
1802 struct Lisp_Char_Table *dp
1803 = window_display_table (XWINDOW (selected_window));
1804 SET_PT (PT - 1);
1805 lose = FETCH_CHAR (PT_BYTE);
1806 if (! NILP (Vpost_command_hook))
1807 goto directly_done;
1808 if (current_buffer == prev_buffer
1809 && last_point_position != PT
1810 && NILP (Vdisable_point_adjustment)
1811 && NILP (Vglobal_disable_point_adjustment))
1812 adjust_point_for_property (last_point_position, 0);
1813 already_adjusted = 1;
1814 if (PT == last_point_position - 1
1815 && (dp
1816 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1817 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1818 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1819 && (lose >= 0x20 && lose < 0x7f)))
1820 : (lose >= 0x20 && lose < 0x7f))
1821 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1822 >= MODIFF)
1823 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1824 >= OVERLAY_MODIFF)
1825 && (XFASTINT (XWINDOW (selected_window)->last_point)
1826 == PT + 1)
1827 && !windows_or_buffers_changed
1828 && EQ (current_buffer->selective_display, Qnil)
1829 && !detect_input_pending ()
1830 && NILP (XWINDOW (selected_window)->column_number_displayed)
1831 && NILP (Vexecuting_kbd_macro))
1832 direct_output_forward_char (-1);
1833 goto directly_done;
1835 else if (EQ (Vthis_command, Qself_insert_command)
1836 /* Try this optimization only on char keystrokes. */
1837 && NATNUMP (last_command_event)
1838 && CHAR_VALID_P (XFASTINT (last_command_event), 0))
1840 unsigned int c
1841 = translate_char (Vtranslation_table_for_input,
1842 XFASTINT (last_command_event));
1843 int value;
1844 if (NILP (Vexecuting_kbd_macro)
1845 && !EQ (minibuf_window, selected_window))
1847 if (!nonundocount || nonundocount >= 20)
1849 Fundo_boundary ();
1850 nonundocount = 0;
1852 nonundocount++;
1855 lose = ((XFASTINT (XWINDOW (selected_window)->last_modified)
1856 < MODIFF)
1857 || (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1858 < OVERLAY_MODIFF)
1859 || (XFASTINT (XWINDOW (selected_window)->last_point)
1860 != PT)
1861 || MODIFF <= SAVE_MODIFF
1862 || windows_or_buffers_changed
1863 || !EQ (current_buffer->selective_display, Qnil)
1864 || detect_input_pending ()
1865 || !NILP (XWINDOW (selected_window)->column_number_displayed)
1866 || !NILP (Vexecuting_kbd_macro));
1868 value = internal_self_insert (c, 0);
1870 if (value == 2)
1871 nonundocount = 0;
1873 frame_make_pointer_invisible ();
1875 if (! NILP (Vpost_command_hook))
1876 /* Put this before calling adjust_point_for_property
1877 so it will only get called once in any case. */
1878 goto directly_done;
1880 /* VALUE == 1 when AFTER-CHANGE functions are
1881 installed which is the case most of the time
1882 because FONT-LOCK installs one. */
1883 if (!lose && !value)
1884 direct_output_for_insert (c);
1885 goto directly_done;
1889 /* Here for a command that isn't executed directly */
1892 #ifdef HAVE_WINDOW_SYSTEM
1893 int scount = SPECPDL_INDEX ();
1895 if (display_hourglass_p
1896 && NILP (Vexecuting_kbd_macro))
1898 record_unwind_protect (cancel_hourglass_unwind, Qnil);
1899 start_hourglass ();
1901 #endif
1903 nonundocount = 0;
1904 if (NILP (current_kboard->Vprefix_arg)) /* FIXME: Why? --Stef */
1905 Fundo_boundary ();
1906 Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
1908 #ifdef HAVE_WINDOW_SYSTEM
1909 /* Do not check display_hourglass_p here, because
1910 Fcommand_execute could change it, but we should cancel
1911 hourglass cursor anyway.
1912 But don't cancel the hourglass within a macro
1913 just because a command in the macro finishes. */
1914 if (NILP (Vexecuting_kbd_macro))
1915 unbind_to (scount, Qnil);
1916 #endif
1919 directly_done: ;
1920 current_kboard->Vlast_prefix_arg = Vcurrent_prefix_arg;
1922 /* Note that the value cell will never directly contain nil
1923 if the symbol is a local variable. */
1924 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1925 safe_run_hooks (Qpost_command_hook);
1927 /* If displaying a message, resize the echo area window to fit
1928 that message's size exactly. */
1929 if (!NILP (echo_area_buffer[0]))
1930 resize_echo_area_exactly ();
1932 if (!NILP (Vdeferred_action_list))
1933 safe_run_hooks (Qdeferred_action_function);
1935 /* If there is a prefix argument,
1936 1) We don't want Vlast_command to be ``universal-argument''
1937 (that would be dumb), so don't set Vlast_command,
1938 2) we want to leave echoing on so that the prefix will be
1939 echoed as part of this key sequence, so don't call
1940 cancel_echoing, and
1941 3) we want to leave this_command_key_count non-zero, so that
1942 read_char will realize that it is re-reading a character, and
1943 not echo it a second time.
1945 If the command didn't actually create a prefix arg,
1946 but is merely a frame event that is transparent to prefix args,
1947 then the above doesn't apply. */
1948 if (NILP (current_kboard->Vprefix_arg) || CONSP (last_command_event))
1950 current_kboard->Vlast_command = Vthis_command;
1951 current_kboard->Vreal_last_command = real_this_command;
1952 if (!CONSP (last_command_event))
1953 current_kboard->Vlast_repeatable_command = real_this_command;
1954 cancel_echoing ();
1955 this_command_key_count = 0;
1956 this_command_key_count_reset = 0;
1957 this_single_command_key_start = 0;
1960 if (!NILP (current_buffer->mark_active) && !NILP (Vrun_hooks))
1962 /* In Emacs 22, setting transient-mark-mode to `only' was a
1963 way of turning it on for just one command. This usage is
1964 obsolete, but support it anyway. */
1965 if (EQ (Vtransient_mark_mode, Qidentity))
1966 Vtransient_mark_mode = Qnil;
1967 else if (EQ (Vtransient_mark_mode, Qonly))
1968 Vtransient_mark_mode = Qidentity;
1970 if (!NILP (Vdeactivate_mark))
1971 call0 (Qdeactivate_mark);
1972 else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
1973 call1 (Vrun_hooks, intern ("activate-mark-hook"));
1976 finalize:
1978 if (current_buffer == prev_buffer
1979 && last_point_position != PT
1980 && NILP (Vdisable_point_adjustment)
1981 && NILP (Vglobal_disable_point_adjustment))
1983 if (last_point_position > BEGV
1984 && last_point_position < ZV
1985 && (composition_adjust_point (last_point_position,
1986 last_point_position)
1987 != last_point_position))
1988 /* The last point was temporarily set within a grapheme
1989 cluster to prevent automatic composition. To recover
1990 the automatic composition, we must update the
1991 display. */
1992 windows_or_buffers_changed++;
1993 if (!already_adjusted)
1994 adjust_point_for_property (last_point_position,
1995 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 */
2004 if (!was_locked)
2005 any_kboard_state ();
2006 #endif
2010 extern Lisp_Object Qcomposition, Qdisplay;
2012 /* Adjust point to a boundary of a region that has such a property
2013 that should be treated intangible. For the moment, we check
2014 `composition', `display' and `invisible' properties.
2015 LAST_PT is the last position of point. */
2017 extern Lisp_Object Qafter_string, Qbefore_string;
2018 extern Lisp_Object get_pos_property P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2020 static void
2021 adjust_point_for_property (last_pt, modified)
2022 int last_pt;
2023 int modified;
2025 EMACS_INT beg, end;
2026 Lisp_Object val, overlay, tmp;
2027 /* When called after buffer modification, we should temporarily
2028 suppress the point adjustment for automatic composition so that a
2029 user can keep inserting another character at point or keep
2030 deleting characters around point. */
2031 int check_composition = ! modified, check_display = 1, check_invisible = 1;
2032 int orig_pt = PT;
2034 /* FIXME: cycling is probably not necessary because these properties
2035 can't be usefully combined anyway. */
2036 while (check_composition || check_display || check_invisible)
2038 /* FIXME: check `intangible'. */
2039 if (check_composition
2040 && PT > BEGV && PT < ZV
2041 && (beg = composition_adjust_point (last_pt, PT)) != PT)
2043 SET_PT (beg);
2044 check_display = check_invisible = 1;
2046 check_composition = 0;
2047 if (check_display
2048 && PT > BEGV && PT < ZV
2049 && !NILP (val = get_char_property_and_overlay
2050 (make_number (PT), Qdisplay, Qnil, &overlay))
2051 && display_prop_intangible_p (val)
2052 && (!OVERLAYP (overlay)
2053 ? get_property_and_range (PT, Qdisplay, &val, &beg, &end, Qnil)
2054 : (beg = OVERLAY_POSITION (OVERLAY_START (overlay)),
2055 end = OVERLAY_POSITION (OVERLAY_END (overlay))))
2056 && (beg < PT /* && end > PT <- It's always the case. */
2057 || (beg <= PT && STRINGP (val) && SCHARS (val) == 0)))
2059 xassert (end > PT);
2060 SET_PT (PT < last_pt
2061 ? (STRINGP (val) && SCHARS (val) == 0 ? beg - 1 : beg)
2062 : end);
2063 check_composition = check_invisible = 1;
2065 check_display = 0;
2066 if (check_invisible && PT > BEGV && PT < ZV)
2068 int inv, ellipsis = 0;
2069 beg = end = PT;
2071 /* Find boundaries `beg' and `end' of the invisible area, if any. */
2072 while (end < ZV
2073 #if 0
2074 /* FIXME: We should stop if we find a spot between
2075 two runs of `invisible' where inserted text would
2076 be visible. This is important when we have two
2077 invisible boundaries that enclose an area: if the
2078 area is empty, we need this test in order to make
2079 it possible to place point in the middle rather
2080 than skip both boundaries. However, this code
2081 also stops anywhere in a non-sticky text-property,
2082 which breaks (e.g.) Org mode. */
2083 && (val = get_pos_property (make_number (end),
2084 Qinvisible, Qnil),
2085 TEXT_PROP_MEANS_INVISIBLE (val))
2086 #endif
2087 && !NILP (val = get_char_property_and_overlay
2088 (make_number (end), 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 = Fnext_single_char_property_change
2096 (make_number (end), Qinvisible, Qnil, Qnil);
2097 end = NATNUMP (tmp) ? XFASTINT (tmp) : ZV;
2099 while (beg > BEGV
2100 #if 0
2101 && (val = get_pos_property (make_number (beg),
2102 Qinvisible, Qnil),
2103 TEXT_PROP_MEANS_INVISIBLE (val))
2104 #endif
2105 && !NILP (val = get_char_property_and_overlay
2106 (make_number (beg - 1), Qinvisible, Qnil, &overlay))
2107 && (inv = TEXT_PROP_MEANS_INVISIBLE (val)))
2109 ellipsis = ellipsis || inv > 1
2110 || (OVERLAYP (overlay)
2111 && (!NILP (Foverlay_get (overlay, Qafter_string))
2112 || !NILP (Foverlay_get (overlay, Qbefore_string))));
2113 tmp = Fprevious_single_char_property_change
2114 (make_number (beg), Qinvisible, Qnil, Qnil);
2115 beg = NATNUMP (tmp) ? XFASTINT (tmp) : BEGV;
2118 /* Move away from the inside area. */
2119 if (beg < PT && end > PT)
2121 SET_PT ((orig_pt == PT && (last_pt < beg || last_pt > end))
2122 /* We haven't moved yet (so we don't need to fear
2123 infinite-looping) and we were outside the range
2124 before (so either end of the range still corresponds
2125 to a move in the right direction): pretend we moved
2126 less than we actually did, so that we still have
2127 more freedom below in choosing which end of the range
2128 to go to. */
2129 ? (orig_pt = -1, PT < last_pt ? end : beg)
2130 /* We either have moved already or the last point
2131 was already in the range: we don't get to choose
2132 which end of the range we have to go to. */
2133 : (PT < last_pt ? beg : end));
2134 check_composition = check_display = 1;
2136 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
2137 the point to something other than its argument, due to
2138 point-motion hooks, intangibility, etc. */
2139 xassert (PT == beg || PT == end);
2140 #endif
2142 /* Pretend the area doesn't exist if the buffer is not
2143 modified. */
2144 if (!modified && !ellipsis && beg < end)
2146 if (last_pt == beg && PT == end && end < ZV)
2147 (check_composition = check_display = 1, SET_PT (end + 1));
2148 else if (last_pt == end && PT == beg && beg > BEGV)
2149 (check_composition = check_display = 1, SET_PT (beg - 1));
2150 else if (PT == ((PT < last_pt) ? beg : end))
2151 /* We've already moved as far as we can. Trying to go
2152 to the other end would mean moving backwards and thus
2153 could lead to an infinite loop. */
2155 else if (val = get_pos_property (make_number (PT),
2156 Qinvisible, Qnil),
2157 TEXT_PROP_MEANS_INVISIBLE (val)
2158 && (val = get_pos_property
2159 (make_number (PT == beg ? end : beg),
2160 Qinvisible, Qnil),
2161 !TEXT_PROP_MEANS_INVISIBLE (val)))
2162 (check_composition = check_display = 1,
2163 SET_PT (PT == beg ? end : beg));
2166 check_invisible = 0;
2170 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2172 static Lisp_Object
2173 safe_run_hooks_1 (hook)
2174 Lisp_Object hook;
2176 if (NILP (Vrun_hooks))
2177 return Qnil;
2178 return call1 (Vrun_hooks, Vinhibit_quit);
2181 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2183 static Lisp_Object
2184 safe_run_hooks_error (data)
2185 Lisp_Object data;
2187 Lisp_Object args[3];
2188 args[0] = build_string ("Error in %s: %s");
2189 args[1] = Vinhibit_quit;
2190 args[2] = data;
2191 Fmessage (3, args);
2192 return Fset (Vinhibit_quit, Qnil);
2195 /* If we get an error while running the hook, cause the hook variable
2196 to be nil. Also inhibit quits, so that C-g won't cause the hook
2197 to mysteriously evaporate. */
2199 void
2200 safe_run_hooks (hook)
2201 Lisp_Object hook;
2203 int count = SPECPDL_INDEX ();
2204 specbind (Qinhibit_quit, hook);
2206 internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
2208 unbind_to (count, Qnil);
2212 /* Number of seconds between polling for input. This is a Lisp
2213 variable that can be bound. */
2215 EMACS_INT polling_period;
2217 /* Nonzero means polling for input is temporarily suppressed. */
2219 int poll_suppress_count;
2221 /* Asynchronous timer for polling. */
2223 struct atimer *poll_timer;
2226 #ifdef POLL_FOR_INPUT
2228 /* Poll for input, so that we catch a C-g if it comes in. This
2229 function is called from x_make_frame_visible, see comment
2230 there. */
2232 void
2233 poll_for_input_1 ()
2235 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
2236 doing anything dangerous. */
2237 #ifdef HAVE_NS
2238 ++handling_signal;
2239 #endif
2240 if (interrupt_input_blocked == 0
2241 && !waiting_for_input)
2242 read_avail_input (0);
2243 #ifdef HAVE_NS
2244 --handling_signal;
2245 #endif
2248 /* Timer callback function for poll_timer. TIMER is equal to
2249 poll_timer. */
2251 void
2252 poll_for_input (timer)
2253 struct atimer *timer;
2255 if (poll_suppress_count == 0)
2257 #ifdef SYNC_INPUT
2258 interrupt_input_pending = 1;
2259 pending_signals = 1;
2260 #else
2261 poll_for_input_1 ();
2262 #endif
2266 #endif /* POLL_FOR_INPUT */
2268 /* Begin signals to poll for input, if they are appropriate.
2269 This function is called unconditionally from various places. */
2271 void
2272 start_polling ()
2274 #ifdef POLL_FOR_INPUT
2275 /* XXX This condition was (read_socket_hook && !interrupt_input),
2276 but read_socket_hook is not global anymore. Let's pretend that
2277 it's always set. */
2278 if (!interrupt_input)
2280 /* Turn alarm handling on unconditionally. It might have
2281 been turned off in process.c. */
2282 turn_on_atimers (1);
2284 /* If poll timer doesn't exist, are we need one with
2285 a different interval, start a new one. */
2286 if (poll_timer == NULL
2287 || EMACS_SECS (poll_timer->interval) != polling_period)
2289 EMACS_TIME interval;
2291 if (poll_timer)
2292 cancel_atimer (poll_timer);
2294 EMACS_SET_SECS_USECS (interval, polling_period, 0);
2295 poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
2296 poll_for_input, NULL);
2299 /* Let the timer's callback function poll for input
2300 if this becomes zero. */
2301 --poll_suppress_count;
2303 #endif
2306 /* Nonzero if we are using polling to handle input asynchronously. */
2309 input_polling_used ()
2311 #ifdef POLL_FOR_INPUT
2312 /* XXX This condition was (read_socket_hook && !interrupt_input),
2313 but read_socket_hook is not global anymore. Let's pretend that
2314 it's always set. */
2315 return !interrupt_input;
2316 #else
2317 return 0;
2318 #endif
2321 /* Turn off polling. */
2323 void
2324 stop_polling ()
2326 #ifdef POLL_FOR_INPUT
2327 /* XXX This condition was (read_socket_hook && !interrupt_input),
2328 but read_socket_hook is not global anymore. Let's pretend that
2329 it's always set. */
2330 if (!interrupt_input)
2331 ++poll_suppress_count;
2332 #endif
2335 /* Set the value of poll_suppress_count to COUNT
2336 and start or stop polling accordingly. */
2338 void
2339 set_poll_suppress_count (count)
2340 int count;
2342 #ifdef POLL_FOR_INPUT
2343 if (count == 0 && poll_suppress_count != 0)
2345 poll_suppress_count = 1;
2346 start_polling ();
2348 else if (count != 0 && poll_suppress_count == 0)
2350 stop_polling ();
2352 poll_suppress_count = count;
2353 #endif
2356 /* Bind polling_period to a value at least N.
2357 But don't decrease it. */
2359 void
2360 bind_polling_period (n)
2361 int n;
2363 #ifdef POLL_FOR_INPUT
2364 int new = polling_period;
2366 if (n > new)
2367 new = n;
2369 stop_other_atimers (poll_timer);
2370 stop_polling ();
2371 specbind (Qpolling_period, make_number (new));
2372 /* Start a new alarm with the new period. */
2373 start_polling ();
2374 #endif
2377 /* Apply the control modifier to CHARACTER. */
2380 make_ctrl_char (c)
2381 int c;
2383 /* Save the upper bits here. */
2384 int upper = c & ~0177;
2386 if (! ASCII_BYTE_P (c))
2387 return c |= ctrl_modifier;
2389 c &= 0177;
2391 /* Everything in the columns containing the upper-case letters
2392 denotes a control character. */
2393 if (c >= 0100 && c < 0140)
2395 int oc = c;
2396 c &= ~0140;
2397 /* Set the shift modifier for a control char
2398 made from a shifted letter. But only for letters! */
2399 if (oc >= 'A' && oc <= 'Z')
2400 c |= shift_modifier;
2403 /* The lower-case letters denote control characters too. */
2404 else if (c >= 'a' && c <= 'z')
2405 c &= ~0140;
2407 /* Include the bits for control and shift
2408 only if the basic ASCII code can't indicate them. */
2409 else if (c >= ' ')
2410 c |= ctrl_modifier;
2412 /* Replace the high bits. */
2413 c |= (upper & ~ctrl_modifier);
2415 return c;
2418 /* Display the help-echo property of the character after the mouse pointer.
2419 Either show it in the echo area, or call show-help-function to display
2420 it by other means (maybe in a tooltip).
2422 If HELP is nil, that means clear the previous help echo.
2424 If HELP is a string, display that string. If HELP is a function,
2425 call it with OBJECT and POS as arguments; the function should
2426 return a help string or nil for none. For all other types of HELP,
2427 evaluate it to obtain a string.
2429 WINDOW is the window in which the help was generated, if any.
2430 It is nil if not in a window.
2432 If OBJECT is a buffer, POS is the position in the buffer where the
2433 `help-echo' text property was found.
2435 If OBJECT is an overlay, that overlay has a `help-echo' property,
2436 and POS is the position in the overlay's buffer under the mouse.
2438 If OBJECT is a string (an overlay string or a string displayed with
2439 the `display' property). POS is the position in that string under
2440 the mouse.
2442 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2443 echo overwrites a keystroke echo currently displayed in the echo
2444 area.
2446 Note: this function may only be called with HELP nil or a string
2447 from X code running asynchronously. */
2449 void
2450 show_help_echo (help, window, object, pos, ok_to_overwrite_keystroke_echo)
2451 Lisp_Object help, window, object, pos;
2452 int ok_to_overwrite_keystroke_echo;
2454 if (!NILP (help) && !STRINGP (help))
2456 if (FUNCTIONP (help))
2458 Lisp_Object args[4];
2459 args[0] = help;
2460 args[1] = window;
2461 args[2] = object;
2462 args[3] = pos;
2463 help = safe_call (4, args);
2465 else
2466 help = safe_eval (help);
2468 if (!STRINGP (help))
2469 return;
2472 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2473 if (!noninteractive && STRINGP (help))
2475 /* The mouse-fixup-help-message Lisp function can call
2476 mouse_position_hook, which resets the mouse_moved flags.
2477 This causes trouble if we are trying to read a mouse motion
2478 event (i.e., if we are inside a `track-mouse' form), so we
2479 restore the mouse_moved flag. */
2480 FRAME_PTR f = NILP (do_mouse_tracking) ? NULL : some_mouse_moved ();
2481 help = call1 (Qmouse_fixup_help_message, help);
2482 if (f)
2483 f->mouse_moved = 1;
2485 #endif
2487 if (STRINGP (help) || NILP (help))
2489 if (!NILP (Vshow_help_function))
2490 call1 (Vshow_help_function, help);
2491 help_echo_showing_p = STRINGP (help);
2497 /* Input of single characters from keyboard */
2499 Lisp_Object print_help ();
2500 static Lisp_Object kbd_buffer_get_event ();
2501 static void record_char ();
2503 static Lisp_Object help_form_saved_window_configs;
2504 static Lisp_Object
2505 read_char_help_form_unwind (Lisp_Object arg)
2507 Lisp_Object window_config = XCAR (help_form_saved_window_configs);
2508 help_form_saved_window_configs = XCDR (help_form_saved_window_configs);
2509 if (!NILP (window_config))
2510 Fset_window_configuration (window_config);
2511 return Qnil;
2514 #define STOP_POLLING \
2515 do { if (! polling_stopped_here) stop_polling (); \
2516 polling_stopped_here = 1; } while (0)
2518 #define RESUME_POLLING \
2519 do { if (polling_stopped_here) start_polling (); \
2520 polling_stopped_here = 0; } while (0)
2522 /* read a character from the keyboard; call the redisplay if needed */
2523 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2524 -1 means do not do redisplay, but do do autosaving.
2525 1 means do both. */
2527 /* The arguments MAPS and NMAPS are for menu prompting.
2528 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2530 PREV_EVENT is the previous input event, or nil if we are reading
2531 the first event of a key sequence (or not reading a key sequence).
2532 If PREV_EVENT is t, that is a "magic" value that says
2533 not to run input methods, but in other respects to act as if
2534 not reading a key sequence.
2536 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2537 if we used a mouse menu to read the input, or zero otherwise. If
2538 USED_MOUSE_MENU is null, we don't dereference it.
2540 Value is -2 when we find input on another keyboard. A second call
2541 to read_char will read it.
2543 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2544 specifying the maximum time to wait until. If no input arrives by
2545 that time, stop waiting and return nil.
2547 Value is t if we showed a menu and the user rejected it. */
2549 Lisp_Object
2550 read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu, end_time)
2551 int commandflag;
2552 int nmaps;
2553 Lisp_Object *maps;
2554 Lisp_Object prev_event;
2555 int *used_mouse_menu;
2556 EMACS_TIME *end_time;
2558 volatile Lisp_Object c;
2559 int count, jmpcount;
2560 jmp_buf local_getcjmp;
2561 jmp_buf save_jump;
2562 volatile int key_already_recorded = 0;
2563 Lisp_Object tem, save;
2564 volatile Lisp_Object previous_echo_area_message;
2565 volatile Lisp_Object also_record;
2566 volatile int reread;
2567 struct gcpro gcpro1, gcpro2;
2568 int polling_stopped_here = 0;
2569 struct kboard *orig_kboard = current_kboard;
2571 also_record = Qnil;
2573 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2574 before_command_key_count = this_command_key_count;
2575 before_command_echo_length = echo_length ();
2576 #endif
2577 c = Qnil;
2578 previous_echo_area_message = Qnil;
2580 GCPRO2 (c, previous_echo_area_message);
2582 retry:
2584 reread = 0;
2585 if (CONSP (Vunread_post_input_method_events))
2587 c = XCAR (Vunread_post_input_method_events);
2588 Vunread_post_input_method_events
2589 = XCDR (Vunread_post_input_method_events);
2591 /* Undo what read_char_x_menu_prompt did when it unread
2592 additional keys returned by Fx_popup_menu. */
2593 if (CONSP (c)
2594 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2595 && NILP (XCDR (c)))
2596 c = XCAR (c);
2598 reread = 1;
2599 goto reread_first;
2602 if (unread_command_char != -1)
2604 XSETINT (c, unread_command_char);
2605 unread_command_char = -1;
2607 reread = 1;
2608 goto reread_first;
2611 if (CONSP (Vunread_command_events))
2613 int was_disabled = 0;
2615 c = XCAR (Vunread_command_events);
2616 Vunread_command_events = XCDR (Vunread_command_events);
2618 reread = 1;
2620 /* Undo what sit-for did when it unread additional keys
2621 inside universal-argument. */
2623 if (CONSP (c)
2624 && EQ (XCAR (c), Qt))
2626 reread = 0;
2627 c = XCDR (c);
2630 /* Undo what read_char_x_menu_prompt did when it unread
2631 additional keys returned by Fx_popup_menu. */
2632 if (CONSP (c)
2633 && EQ (XCDR (c), Qdisabled)
2634 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c))))
2636 was_disabled = 1;
2637 c = XCAR (c);
2640 /* If the queued event is something that used the mouse,
2641 set used_mouse_menu accordingly. */
2642 if (used_mouse_menu
2643 /* Also check was_disabled so last-nonmenu-event won't return
2644 a bad value when submenus are involved. (Bug#447) */
2645 && (EQ (c, Qtool_bar) || EQ (c, Qmenu_bar) || was_disabled))
2646 *used_mouse_menu = 1;
2648 goto reread_for_input_method;
2651 if (CONSP (Vunread_input_method_events))
2653 c = XCAR (Vunread_input_method_events);
2654 Vunread_input_method_events = XCDR (Vunread_input_method_events);
2656 /* Undo what read_char_x_menu_prompt did when it unread
2657 additional keys returned by Fx_popup_menu. */
2658 if (CONSP (c)
2659 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2660 && NILP (XCDR (c)))
2661 c = XCAR (c);
2662 reread = 1;
2663 goto reread_for_input_method;
2666 this_command_key_count_reset = 0;
2668 if (!NILP (Vexecuting_kbd_macro))
2670 /* We set this to Qmacro; since that's not a frame, nobody will
2671 try to switch frames on us, and the selected window will
2672 remain unchanged.
2674 Since this event came from a macro, it would be misleading to
2675 leave internal_last_event_frame set to wherever the last
2676 real event came from. Normally, a switch-frame event selects
2677 internal_last_event_frame after each command is read, but
2678 events read from a macro should never cause a new frame to be
2679 selected. */
2680 Vlast_event_frame = internal_last_event_frame = Qmacro;
2682 /* Exit the macro if we are at the end.
2683 Also, some things replace the macro with t
2684 to force an early exit. */
2685 if (EQ (Vexecuting_kbd_macro, Qt)
2686 || executing_kbd_macro_index >= XFASTINT (Flength (Vexecuting_kbd_macro)))
2688 XSETINT (c, -1);
2689 goto exit;
2692 c = Faref (Vexecuting_kbd_macro, make_number (executing_kbd_macro_index));
2693 if (STRINGP (Vexecuting_kbd_macro)
2694 && (XINT (c) & 0x80) && (XUINT (c) <= 0xff))
2695 XSETFASTINT (c, CHAR_META | (XINT (c) & ~0x80));
2697 executing_kbd_macro_index++;
2699 goto from_macro;
2702 if (!NILP (unread_switch_frame))
2704 c = unread_switch_frame;
2705 unread_switch_frame = Qnil;
2707 /* This event should make it into this_command_keys, and get echoed
2708 again, so we do not set `reread'. */
2709 goto reread_first;
2712 /* if redisplay was requested */
2713 if (commandflag >= 0)
2715 int echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
2717 /* If there is pending input, process any events which are not
2718 user-visible, such as X selection_request events. */
2719 if (input_pending
2720 || detect_input_pending_run_timers (0))
2721 swallow_events (0); /* may clear input_pending */
2723 /* Redisplay if no pending input. */
2724 while (!input_pending)
2726 if (help_echo_showing_p && !EQ (selected_window, minibuf_window))
2727 redisplay_preserve_echo_area (5);
2728 else
2729 redisplay ();
2731 if (!input_pending)
2732 /* Normal case: no input arrived during redisplay. */
2733 break;
2735 /* Input arrived and pre-empted redisplay.
2736 Process any events which are not user-visible. */
2737 swallow_events (0);
2738 /* If that cleared input_pending, try again to redisplay. */
2741 /* Prevent the redisplay we just did
2742 from messing up echoing of the input after the prompt. */
2743 if (commandflag == 0 && echo_current)
2744 echo_message_buffer = echo_area_buffer[0];
2748 /* Message turns off echoing unless more keystrokes turn it on again.
2750 The code in 20.x for the condition was
2752 1. echo_area_glyphs && *echo_area_glyphs
2753 2. && echo_area_glyphs != current_kboard->echobuf
2754 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2756 (1) means there's a current message displayed
2758 (2) means it's not the message from echoing from the current
2759 kboard.
2761 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2762 is set to a non-null value. This is done in read_char and it is
2763 set to echo_area_glyphs after a call to echo_char. That means
2764 ok_to_echo_at_next_pause is either null or
2765 current_kboard->echobuf with the appropriate current_kboard at
2766 that time.
2768 So, condition (3) means in clear text ok_to_echo_at_next_pause
2769 must be either null, or the current message isn't from echoing at
2770 all, or it's from echoing from a different kboard than the
2771 current one. */
2773 if (/* There currently is something in the echo area. */
2774 !NILP (echo_area_buffer[0])
2775 && (/* And it's either not from echoing. */
2776 !EQ (echo_area_buffer[0], echo_message_buffer)
2777 /* Or it's an echo from a different kboard. */
2778 || echo_kboard != current_kboard
2779 /* Or we explicitly allow overwriting whatever there is. */
2780 || ok_to_echo_at_next_pause == NULL))
2781 cancel_echoing ();
2782 else
2783 echo_dash ();
2785 /* Try reading a character via menu prompting in the minibuf.
2786 Try this before the sit-for, because the sit-for
2787 would do the wrong thing if we are supposed to do
2788 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2789 after a mouse event so don't try a minibuf menu. */
2790 c = Qnil;
2791 if (nmaps > 0 && INTERACTIVE
2792 && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
2793 /* Don't bring up a menu if we already have another event. */
2794 && NILP (Vunread_command_events)
2795 && unread_command_char < 0
2796 && !detect_input_pending_run_timers (0))
2798 c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
2800 if (INTEGERP (c) && XINT (c) == -2)
2801 return c; /* wrong_kboard_jmpbuf */
2803 if (! NILP (c))
2805 key_already_recorded = 1;
2806 goto non_reread_1;
2810 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2811 We will do that below, temporarily for short sections of code,
2812 when appropriate. local_getcjmp must be in effect
2813 around any call to sit_for or kbd_buffer_get_event;
2814 it *must not* be in effect when we call redisplay. */
2816 jmpcount = SPECPDL_INDEX ();
2817 if (_setjmp (local_getcjmp))
2819 /* Handle quits while reading the keyboard. */
2820 /* We must have saved the outer value of getcjmp here,
2821 so restore it now. */
2822 restore_getcjmp (save_jump);
2823 unbind_to (jmpcount, Qnil);
2824 XSETINT (c, quit_char);
2825 internal_last_event_frame = selected_frame;
2826 Vlast_event_frame = internal_last_event_frame;
2827 /* If we report the quit char as an event,
2828 don't do so more than once. */
2829 if (!NILP (Vinhibit_quit))
2830 Vquit_flag = Qnil;
2833 KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
2834 if (kb != current_kboard)
2836 Lisp_Object link = kb->kbd_queue;
2837 /* We shouldn't get here if we were in single-kboard mode! */
2838 if (single_kboard)
2839 abort ();
2840 if (CONSP (link))
2842 while (CONSP (XCDR (link)))
2843 link = XCDR (link);
2844 if (!NILP (XCDR (link)))
2845 abort ();
2847 if (!CONSP (link))
2848 kb->kbd_queue = Fcons (c, Qnil);
2849 else
2850 XSETCDR (link, Fcons (c, Qnil));
2851 kb->kbd_queue_has_data = 1;
2852 current_kboard = kb;
2853 /* This is going to exit from read_char
2854 so we had better get rid of this frame's stuff. */
2855 UNGCPRO;
2856 return make_number (-2); /* wrong_kboard_jmpbuf */
2859 goto non_reread;
2862 /* Start idle timers if no time limit is supplied. We don't do it
2863 if a time limit is supplied to avoid an infinite recursion in the
2864 situation where an idle timer calls `sit-for'. */
2866 if (!end_time)
2867 timer_start_idle ();
2869 /* If in middle of key sequence and minibuffer not active,
2870 start echoing if enough time elapses. */
2872 if (minibuf_level == 0
2873 && !end_time
2874 && !current_kboard->immediate_echo
2875 && this_command_key_count > 0
2876 && ! noninteractive
2877 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2878 && NILP (Fzerop (Vecho_keystrokes))
2879 && (/* No message. */
2880 NILP (echo_area_buffer[0])
2881 /* Or empty message. */
2882 || (BUF_BEG (XBUFFER (echo_area_buffer[0]))
2883 == BUF_Z (XBUFFER (echo_area_buffer[0])))
2884 /* Or already echoing from same kboard. */
2885 || (echo_kboard && ok_to_echo_at_next_pause == echo_kboard)
2886 /* Or not echoing before and echoing allowed. */
2887 || (!echo_kboard && ok_to_echo_at_next_pause)))
2889 /* After a mouse event, start echoing right away.
2890 This is because we are probably about to display a menu,
2891 and we don't want to delay before doing so. */
2892 if (EVENT_HAS_PARAMETERS (prev_event))
2893 echo_now ();
2894 else
2896 Lisp_Object tem0;
2898 save_getcjmp (save_jump);
2899 restore_getcjmp (local_getcjmp);
2900 tem0 = sit_for (Vecho_keystrokes, 1, 1);
2901 restore_getcjmp (save_jump);
2902 if (EQ (tem0, Qt)
2903 && ! CONSP (Vunread_command_events))
2904 echo_now ();
2908 /* Maybe auto save due to number of keystrokes. */
2910 if (commandflag != 0
2911 && auto_save_interval > 0
2912 && num_nonmacro_input_events - last_auto_save > max (auto_save_interval, 20)
2913 && !detect_input_pending_run_timers (0))
2915 Fdo_auto_save (Qnil, Qnil);
2916 /* Hooks can actually change some buffers in auto save. */
2917 redisplay ();
2920 /* Try reading using an X menu.
2921 This is never confused with reading using the minibuf
2922 because the recursive call of read_char in read_char_minibuf_menu_prompt
2923 does not pass on any keymaps. */
2925 if (nmaps > 0 && INTERACTIVE
2926 && !NILP (prev_event)
2927 && EVENT_HAS_PARAMETERS (prev_event)
2928 && !EQ (XCAR (prev_event), Qmenu_bar)
2929 && !EQ (XCAR (prev_event), Qtool_bar)
2930 /* Don't bring up a menu if we already have another event. */
2931 && NILP (Vunread_command_events)
2932 && unread_command_char < 0)
2934 c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
2936 /* Now that we have read an event, Emacs is not idle. */
2937 if (!end_time)
2938 timer_stop_idle ();
2940 goto exit;
2943 /* Maybe autosave and/or garbage collect due to idleness. */
2945 if (INTERACTIVE && NILP (c))
2947 int delay_level, buffer_size;
2949 /* Slow down auto saves logarithmically in size of current buffer,
2950 and garbage collect while we're at it. */
2951 if (! MINI_WINDOW_P (XWINDOW (selected_window)))
2952 last_non_minibuf_size = Z - BEG;
2953 buffer_size = (last_non_minibuf_size >> 8) + 1;
2954 delay_level = 0;
2955 while (buffer_size > 64)
2956 delay_level++, buffer_size -= buffer_size >> 2;
2957 if (delay_level < 4) delay_level = 4;
2958 /* delay_level is 4 for files under around 50k, 7 at 100k,
2959 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2961 /* Auto save if enough time goes by without input. */
2962 if (commandflag != 0
2963 && num_nonmacro_input_events > last_auto_save
2964 && INTEGERP (Vauto_save_timeout)
2965 && XINT (Vauto_save_timeout) > 0)
2967 Lisp_Object tem0;
2968 int timeout = delay_level * XFASTINT (Vauto_save_timeout) / 4;
2970 save_getcjmp (save_jump);
2971 restore_getcjmp (local_getcjmp);
2972 tem0 = sit_for (make_number (timeout), 1, 1);
2973 restore_getcjmp (save_jump);
2975 if (EQ (tem0, Qt)
2976 && ! CONSP (Vunread_command_events))
2978 Fdo_auto_save (Qnil, Qnil);
2980 /* If we have auto-saved and there is still no input
2981 available, garbage collect if there has been enough
2982 consing going on to make it worthwhile. */
2983 if (!detect_input_pending_run_timers (0)
2984 && consing_since_gc > gc_cons_threshold / 2)
2985 Fgarbage_collect ();
2987 redisplay ();
2992 /* Notify the caller if an autosave hook, or a timer, sentinel or
2993 filter in the sit_for calls above have changed the current
2994 kboard. This could happen if they use the minibuffer or start a
2995 recursive edit, like the fancy splash screen in server.el's
2996 filter. If this longjmp wasn't here, read_key_sequence would
2997 interpret the next key sequence using the wrong translation
2998 tables and function keymaps. */
2999 if (NILP (c) && current_kboard != orig_kboard)
3001 UNGCPRO;
3002 return make_number (-2); /* wrong_kboard_jmpbuf */
3005 /* If this has become non-nil here, it has been set by a timer
3006 or sentinel or filter. */
3007 if (CONSP (Vunread_command_events))
3009 c = XCAR (Vunread_command_events);
3010 Vunread_command_events = XCDR (Vunread_command_events);
3013 /* Read something from current KBOARD's side queue, if possible. */
3015 if (NILP (c))
3017 if (current_kboard->kbd_queue_has_data)
3019 if (!CONSP (current_kboard->kbd_queue))
3020 abort ();
3021 c = XCAR (current_kboard->kbd_queue);
3022 current_kboard->kbd_queue
3023 = XCDR (current_kboard->kbd_queue);
3024 if (NILP (current_kboard->kbd_queue))
3025 current_kboard->kbd_queue_has_data = 0;
3026 input_pending = readable_events (0);
3027 if (EVENT_HAS_PARAMETERS (c)
3028 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qswitch_frame))
3029 internal_last_event_frame = XCAR (XCDR (c));
3030 Vlast_event_frame = internal_last_event_frame;
3034 /* If current_kboard's side queue is empty check the other kboards.
3035 If one of them has data that we have not yet seen here,
3036 switch to it and process the data waiting for it.
3038 Note: if the events queued up for another kboard
3039 have already been seen here, and therefore are not a complete command,
3040 the kbd_queue_has_data field is 0, so we skip that kboard here.
3041 That's to avoid an infinite loop switching between kboards here. */
3042 if (NILP (c) && !single_kboard)
3044 KBOARD *kb;
3045 for (kb = all_kboards; kb; kb = kb->next_kboard)
3046 if (kb->kbd_queue_has_data)
3048 current_kboard = kb;
3049 /* This is going to exit from read_char
3050 so we had better get rid of this frame's stuff. */
3051 UNGCPRO;
3052 return make_number (-2); /* wrong_kboard_jmpbuf */
3056 wrong_kboard:
3058 STOP_POLLING;
3060 /* Finally, we read from the main queue,
3061 and if that gives us something we can't use yet, we put it on the
3062 appropriate side queue and try again. */
3064 if (NILP (c))
3066 KBOARD *kb;
3068 if (end_time)
3070 EMACS_TIME now;
3071 EMACS_GET_TIME (now);
3072 if (EMACS_TIME_GE (now, *end_time))
3073 goto exit;
3076 /* Actually read a character, waiting if necessary. */
3077 save_getcjmp (save_jump);
3078 restore_getcjmp (local_getcjmp);
3079 if (!end_time)
3080 timer_start_idle ();
3081 c = kbd_buffer_get_event (&kb, used_mouse_menu, end_time);
3082 restore_getcjmp (save_jump);
3084 if (! NILP (c) && (kb != current_kboard))
3086 Lisp_Object link = kb->kbd_queue;
3087 if (CONSP (link))
3089 while (CONSP (XCDR (link)))
3090 link = XCDR (link);
3091 if (!NILP (XCDR (link)))
3092 abort ();
3094 if (!CONSP (link))
3095 kb->kbd_queue = Fcons (c, Qnil);
3096 else
3097 XSETCDR (link, Fcons (c, Qnil));
3098 kb->kbd_queue_has_data = 1;
3099 c = Qnil;
3100 if (single_kboard)
3101 goto wrong_kboard;
3102 current_kboard = kb;
3103 /* This is going to exit from read_char
3104 so we had better get rid of this frame's stuff. */
3105 UNGCPRO;
3106 return make_number (-2);
3110 /* Terminate Emacs in batch mode if at eof. */
3111 if (noninteractive && INTEGERP (c) && XINT (c) < 0)
3112 Fkill_emacs (make_number (1));
3114 if (INTEGERP (c))
3116 /* Add in any extra modifiers, where appropriate. */
3117 if ((extra_keyboard_modifiers & CHAR_CTL)
3118 || ((extra_keyboard_modifiers & 0177) < ' '
3119 && (extra_keyboard_modifiers & 0177) != 0))
3120 XSETINT (c, make_ctrl_char (XINT (c)));
3122 /* Transfer any other modifier bits directly from
3123 extra_keyboard_modifiers to c. Ignore the actual character code
3124 in the low 16 bits of extra_keyboard_modifiers. */
3125 XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
3128 non_reread:
3130 if (!end_time)
3131 timer_stop_idle ();
3132 RESUME_POLLING;
3134 if (NILP (c))
3136 if (commandflag >= 0
3137 && !input_pending && !detect_input_pending_run_timers (0))
3138 redisplay ();
3140 goto wrong_kboard;
3143 non_reread_1:
3145 /* Buffer switch events are only for internal wakeups
3146 so don't show them to the user.
3147 Also, don't record a key if we already did. */
3148 if (BUFFERP (c) || key_already_recorded)
3149 goto exit;
3151 /* Process special events within read_char
3152 and loop around to read another event. */
3153 save = Vquit_flag;
3154 Vquit_flag = Qnil;
3155 tem = access_keymap (get_keymap (Vspecial_event_map, 0, 1), c, 0, 0, 1);
3156 Vquit_flag = save;
3158 if (!NILP (tem))
3160 struct buffer *prev_buffer = current_buffer;
3161 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3162 int was_locked = single_kboard;
3163 int count = SPECPDL_INDEX ();
3164 record_single_kboard_state ();
3165 #endif
3167 last_input_event = c;
3168 Fcommand_execute (tem, Qnil, Fvector (1, &last_input_event), Qt);
3170 if (CONSP (c) && EQ (XCAR (c), Qselect_window) && !end_time)
3171 /* We stopped being idle for this event; undo that. This
3172 prevents automatic window selection (under
3173 mouse_autoselect_window from acting as a real input event, for
3174 example banishing the mouse under mouse-avoidance-mode. */
3175 timer_resume_idle ();
3177 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3178 /* Resume allowing input from any kboard, if that was true before. */
3179 if (!was_locked)
3180 any_kboard_state ();
3181 unbind_to (count, Qnil);
3182 #endif
3184 if (current_buffer != prev_buffer)
3186 /* The command may have changed the keymaps. Pretend there
3187 is input in another keyboard and return. This will
3188 recalculate keymaps. */
3189 c = make_number (-2);
3190 goto exit;
3192 else
3193 goto retry;
3196 /* Handle things that only apply to characters. */
3197 if (INTEGERP (c))
3199 /* If kbd_buffer_get_event gave us an EOF, return that. */
3200 if (XINT (c) == -1)
3201 goto exit;
3203 if ((STRINGP (current_kboard->Vkeyboard_translate_table)
3204 && SCHARS (current_kboard->Vkeyboard_translate_table) > (unsigned) XFASTINT (c))
3205 || (VECTORP (current_kboard->Vkeyboard_translate_table)
3206 && XVECTOR (current_kboard->Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
3207 || (CHAR_TABLE_P (current_kboard->Vkeyboard_translate_table)
3208 && CHARACTERP (c)))
3210 Lisp_Object d;
3211 d = Faref (current_kboard->Vkeyboard_translate_table, c);
3212 /* nil in keyboard-translate-table means no translation. */
3213 if (!NILP (d))
3214 c = d;
3218 /* If this event is a mouse click in the menu bar,
3219 return just menu-bar for now. Modify the mouse click event
3220 so we won't do this twice, then queue it up. */
3221 if (EVENT_HAS_PARAMETERS (c)
3222 && CONSP (XCDR (c))
3223 && CONSP (EVENT_START (c))
3224 && CONSP (XCDR (EVENT_START (c))))
3226 Lisp_Object posn;
3228 posn = POSN_POSN (EVENT_START (c));
3229 /* Handle menu-bar events:
3230 insert the dummy prefix event `menu-bar'. */
3231 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
3233 /* Change menu-bar to (menu-bar) as the event "position". */
3234 POSN_SET_POSN (EVENT_START (c), Fcons (posn, Qnil));
3236 also_record = c;
3237 Vunread_command_events = Fcons (c, Vunread_command_events);
3238 c = posn;
3242 /* Store these characters into recent_keys, the dribble file if any,
3243 and the keyboard macro being defined, if any. */
3244 record_char (c);
3245 if (! NILP (also_record))
3246 record_char (also_record);
3248 /* Wipe the echo area.
3249 But first, if we are about to use an input method,
3250 save the echo area contents for it to refer to. */
3251 if (INTEGERP (c)
3252 && ! NILP (Vinput_method_function)
3253 && (unsigned) XINT (c) >= ' '
3254 && (unsigned) XINT (c) != 127
3255 && (unsigned) XINT (c) < 256)
3257 previous_echo_area_message = Fcurrent_message ();
3258 Vinput_method_previous_message = previous_echo_area_message;
3261 /* Now wipe the echo area, except for help events which do their
3262 own stuff with the echo area. */
3263 if (!CONSP (c)
3264 || (!(EQ (Qhelp_echo, XCAR (c)))
3265 && !(EQ (Qswitch_frame, XCAR (c)))))
3267 if (!NILP (echo_area_buffer[0]))
3268 safe_run_hooks (Qecho_area_clear_hook);
3269 clear_message (1, 0);
3272 reread_for_input_method:
3273 from_macro:
3274 /* Pass this to the input method, if appropriate. */
3275 if (INTEGERP (c)
3276 && ! NILP (Vinput_method_function)
3277 /* Don't run the input method within a key sequence,
3278 after the first event of the key sequence. */
3279 && NILP (prev_event)
3280 && (unsigned) XINT (c) >= ' '
3281 && (unsigned) XINT (c) != 127
3282 && (unsigned) XINT (c) < 256)
3284 Lisp_Object keys;
3285 int key_count, key_count_reset;
3286 struct gcpro gcpro1;
3287 int count = SPECPDL_INDEX ();
3289 /* Save the echo status. */
3290 int saved_immediate_echo = current_kboard->immediate_echo;
3291 struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
3292 Lisp_Object saved_echo_string = current_kboard->echo_string;
3293 int saved_echo_after_prompt = current_kboard->echo_after_prompt;
3295 #if 0
3296 if (before_command_restore_flag)
3298 this_command_key_count = before_command_key_count_1;
3299 if (this_command_key_count < this_single_command_key_start)
3300 this_single_command_key_start = this_command_key_count;
3301 echo_truncate (before_command_echo_length_1);
3302 before_command_restore_flag = 0;
3304 #endif
3306 /* Save the this_command_keys status. */
3307 key_count = this_command_key_count;
3308 key_count_reset = this_command_key_count_reset;
3310 if (key_count > 0)
3311 keys = Fcopy_sequence (this_command_keys);
3312 else
3313 keys = Qnil;
3314 GCPRO1 (keys);
3316 /* Clear out this_command_keys. */
3317 this_command_key_count = 0;
3318 this_command_key_count_reset = 0;
3320 /* Now wipe the echo area. */
3321 if (!NILP (echo_area_buffer[0]))
3322 safe_run_hooks (Qecho_area_clear_hook);
3323 clear_message (1, 0);
3324 echo_truncate (0);
3326 /* If we are not reading a key sequence,
3327 never use the echo area. */
3328 if (maps == 0)
3330 specbind (Qinput_method_use_echo_area, Qt);
3333 /* Call the input method. */
3334 tem = call1 (Vinput_method_function, c);
3336 tem = unbind_to (count, tem);
3338 /* Restore the saved echoing state
3339 and this_command_keys state. */
3340 this_command_key_count = key_count;
3341 this_command_key_count_reset = key_count_reset;
3342 if (key_count > 0)
3343 this_command_keys = keys;
3345 cancel_echoing ();
3346 ok_to_echo_at_next_pause = saved_ok_to_echo;
3347 current_kboard->echo_string = saved_echo_string;
3348 current_kboard->echo_after_prompt = saved_echo_after_prompt;
3349 if (saved_immediate_echo)
3350 echo_now ();
3352 UNGCPRO;
3354 /* The input method can return no events. */
3355 if (! CONSP (tem))
3357 /* Bring back the previous message, if any. */
3358 if (! NILP (previous_echo_area_message))
3359 message_with_string ("%s", previous_echo_area_message, 0);
3360 goto retry;
3362 /* It returned one event or more. */
3363 c = XCAR (tem);
3364 Vunread_post_input_method_events
3365 = nconc2 (XCDR (tem), Vunread_post_input_method_events);
3368 reread_first:
3370 /* Display help if not echoing. */
3371 if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
3373 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3374 Lisp_Object help, object, position, window, tem;
3376 tem = Fcdr (XCDR (c));
3377 help = Fcar (tem);
3378 tem = Fcdr (tem);
3379 window = Fcar (tem);
3380 tem = Fcdr (tem);
3381 object = Fcar (tem);
3382 tem = Fcdr (tem);
3383 position = Fcar (tem);
3385 show_help_echo (help, window, object, position, 0);
3387 /* We stopped being idle for this event; undo that. */
3388 if (!end_time)
3389 timer_resume_idle ();
3390 goto retry;
3393 if ((! reread || this_command_key_count == 0
3394 || this_command_key_count_reset)
3395 && !end_time)
3398 /* Don't echo mouse motion events. */
3399 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
3400 && NILP (Fzerop (Vecho_keystrokes))
3401 && ! (EVENT_HAS_PARAMETERS (c)
3402 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
3404 echo_char (c);
3405 if (! NILP (also_record))
3406 echo_char (also_record);
3407 /* Once we reread a character, echoing can happen
3408 the next time we pause to read a new one. */
3409 ok_to_echo_at_next_pause = current_kboard;
3412 /* Record this character as part of the current key. */
3413 add_command_key (c);
3414 if (! NILP (also_record))
3415 add_command_key (also_record);
3418 last_input_event = c;
3419 num_input_events++;
3421 /* Process the help character specially if enabled */
3422 if (!NILP (Vhelp_form) && help_char_p (c))
3424 Lisp_Object tem0;
3425 count = SPECPDL_INDEX ();
3427 help_form_saved_window_configs
3428 = Fcons (Fcurrent_window_configuration (Qnil),
3429 help_form_saved_window_configs);
3430 record_unwind_protect (read_char_help_form_unwind, Qnil);
3432 tem0 = Feval (Vhelp_form);
3433 if (STRINGP (tem0))
3434 internal_with_output_to_temp_buffer ("*Help*", print_help, tem0);
3436 cancel_echoing ();
3439 c = read_char (0, 0, 0, Qnil, 0, NULL);
3440 if (EVENT_HAS_PARAMETERS (c)
3441 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_click))
3442 XSETCAR (help_form_saved_window_configs, Qnil);
3444 while (BUFFERP (c));
3445 /* Remove the help from the frame */
3446 unbind_to (count, Qnil);
3448 redisplay ();
3449 if (EQ (c, make_number (040)))
3451 cancel_echoing ();
3453 c = read_char (0, 0, 0, Qnil, 0, NULL);
3454 while (BUFFERP (c));
3458 exit:
3459 RESUME_POLLING;
3460 RETURN_UNGCPRO (c);
3463 /* Record a key that came from a mouse menu.
3464 Record it for echoing, for this-command-keys, and so on. */
3466 static void
3467 record_menu_key (c)
3468 Lisp_Object c;
3470 /* Wipe the echo area. */
3471 clear_message (1, 0);
3473 record_char (c);
3475 #if 0
3476 before_command_key_count = this_command_key_count;
3477 before_command_echo_length = echo_length ();
3478 #endif
3480 /* Don't echo mouse motion events. */
3481 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
3482 && NILP (Fzerop (Vecho_keystrokes)))
3484 echo_char (c);
3486 /* Once we reread a character, echoing can happen
3487 the next time we pause to read a new one. */
3488 ok_to_echo_at_next_pause = 0;
3491 /* Record this character as part of the current key. */
3492 add_command_key (c);
3494 /* Re-reading in the middle of a command */
3495 last_input_event = c;
3496 num_input_events++;
3499 /* Return 1 if should recognize C as "the help character". */
3502 help_char_p (c)
3503 Lisp_Object c;
3505 Lisp_Object tail;
3507 if (EQ (c, Vhelp_char))
3508 return 1;
3509 for (tail = Vhelp_event_list; CONSP (tail); tail = XCDR (tail))
3510 if (EQ (c, XCAR (tail)))
3511 return 1;
3512 return 0;
3515 /* Record the input event C in various ways. */
3517 static void
3518 record_char (c)
3519 Lisp_Object c;
3521 int recorded = 0;
3523 if (CONSP (c) && (EQ (XCAR (c), Qhelp_echo) || EQ (XCAR (c), Qmouse_movement)))
3525 /* To avoid filling recent_keys with help-echo and mouse-movement
3526 events, we filter out repeated help-echo events, only store the
3527 first and last in a series of mouse-movement events, and don't
3528 store repeated help-echo events which are only separated by
3529 mouse-movement events. */
3531 Lisp_Object ev1, ev2, ev3;
3532 int ix1, ix2, ix3;
3534 if ((ix1 = recent_keys_index - 1) < 0)
3535 ix1 = NUM_RECENT_KEYS - 1;
3536 ev1 = AREF (recent_keys, ix1);
3538 if ((ix2 = ix1 - 1) < 0)
3539 ix2 = NUM_RECENT_KEYS - 1;
3540 ev2 = AREF (recent_keys, ix2);
3542 if ((ix3 = ix2 - 1) < 0)
3543 ix3 = NUM_RECENT_KEYS - 1;
3544 ev3 = AREF (recent_keys, ix3);
3546 if (EQ (XCAR (c), Qhelp_echo))
3548 /* Don't record `help-echo' in recent_keys unless it shows some help
3549 message, and a different help than the previously recorded
3550 event. */
3551 Lisp_Object help, last_help;
3553 help = Fcar_safe (Fcdr_safe (XCDR (c)));
3554 if (!STRINGP (help))
3555 recorded = 1;
3556 else if (CONSP (ev1) && EQ (XCAR (ev1), Qhelp_echo)
3557 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev1))), EQ (last_help, help)))
3558 recorded = 1;
3559 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3560 && CONSP (ev2) && EQ (XCAR (ev2), Qhelp_echo)
3561 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev2))), EQ (last_help, help)))
3562 recorded = -1;
3563 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3564 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3565 && CONSP (ev3) && EQ (XCAR (ev3), Qhelp_echo)
3566 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev3))), EQ (last_help, help)))
3567 recorded = -2;
3569 else if (EQ (XCAR (c), Qmouse_movement))
3571 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3572 So additional mouse movement events replace the last element. */
3573 Lisp_Object last_window, window;
3575 window = Fcar_safe (Fcar_safe (XCDR (c)));
3576 if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3577 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev1))), EQ (last_window, window))
3578 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3579 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev2))), EQ (last_window, window)))
3581 ASET (recent_keys, ix1, c);
3582 recorded = 1;
3586 else
3587 store_kbd_macro_char (c);
3589 if (!recorded)
3591 total_keys++;
3592 ASET (recent_keys, recent_keys_index, c);
3593 if (++recent_keys_index >= NUM_RECENT_KEYS)
3594 recent_keys_index = 0;
3596 else if (recorded < 0)
3598 /* We need to remove one or two events from recent_keys.
3599 To do this, we simply put nil at those events and move the
3600 recent_keys_index backwards over those events. Usually,
3601 users will never see those nil events, as they will be
3602 overwritten by the command keys entered to see recent_keys
3603 (e.g. C-h l). */
3605 while (recorded++ < 0 && total_keys > 0)
3607 if (total_keys < NUM_RECENT_KEYS)
3608 total_keys--;
3609 if (--recent_keys_index < 0)
3610 recent_keys_index = NUM_RECENT_KEYS - 1;
3611 ASET (recent_keys, recent_keys_index, Qnil);
3615 num_nonmacro_input_events++;
3617 /* Write c to the dribble file. If c is a lispy event, write
3618 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3619 If you, dear reader, have a better idea, you've got the source. :-) */
3620 if (dribble)
3622 BLOCK_INPUT;
3623 if (INTEGERP (c))
3625 if (XUINT (c) < 0x100)
3626 putc (XINT (c), dribble);
3627 else
3628 fprintf (dribble, " 0x%x", (int) XUINT (c));
3630 else
3632 Lisp_Object dribblee;
3634 /* If it's a structured event, take the event header. */
3635 dribblee = EVENT_HEAD (c);
3637 if (SYMBOLP (dribblee))
3639 putc ('<', dribble);
3640 fwrite (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
3641 SBYTES (SYMBOL_NAME (dribblee)),
3642 dribble);
3643 putc ('>', dribble);
3647 fflush (dribble);
3648 UNBLOCK_INPUT;
3652 Lisp_Object
3653 print_help (object)
3654 Lisp_Object object;
3656 struct buffer *old = current_buffer;
3657 Fprinc (object, Qnil);
3658 set_buffer_internal (XBUFFER (Vstandard_output));
3659 call0 (intern ("help-mode"));
3660 set_buffer_internal (old);
3661 return Qnil;
3664 /* Copy out or in the info on where C-g should throw to.
3665 This is used when running Lisp code from within get_char,
3666 in case get_char is called recursively.
3667 See read_process_output. */
3669 static void
3670 save_getcjmp (temp)
3671 jmp_buf temp;
3673 bcopy (getcjmp, temp, sizeof getcjmp);
3676 static void
3677 restore_getcjmp (temp)
3678 jmp_buf temp;
3680 bcopy (temp, getcjmp, sizeof getcjmp);
3683 /* Low level keyboard/mouse input.
3684 kbd_buffer_store_event places events in kbd_buffer, and
3685 kbd_buffer_get_event retrieves them. */
3687 /* Return true if there are any events in the queue that read-char
3688 would return. If this returns false, a read-char would block. */
3689 static int
3690 readable_events (flags)
3691 int flags;
3693 #ifdef HAVE_DBUS
3694 /* Check whether a D-Bus message has arrived. */
3695 if (xd_pending_messages () > 0)
3696 return 1;
3697 #endif /* HAVE_DBUS */
3699 if (flags & READABLE_EVENTS_DO_TIMERS_NOW)
3700 timer_check (1);
3702 /* If the buffer contains only FOCUS_IN_EVENT events, and
3703 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3704 if (kbd_fetch_ptr != kbd_store_ptr)
3706 if (flags & (READABLE_EVENTS_FILTER_EVENTS
3707 #ifdef USE_TOOLKIT_SCROLL_BARS
3708 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3709 #endif
3712 struct input_event *event;
3714 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3715 ? kbd_fetch_ptr
3716 : kbd_buffer);
3720 if (!(
3721 #ifdef USE_TOOLKIT_SCROLL_BARS
3722 (flags & READABLE_EVENTS_FILTER_EVENTS) &&
3723 #endif
3724 event->kind == FOCUS_IN_EVENT)
3725 #ifdef USE_TOOLKIT_SCROLL_BARS
3726 && !((flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
3727 && event->kind == SCROLL_BAR_CLICK_EVENT
3728 && event->part == scroll_bar_handle
3729 && event->modifiers == 0)
3730 #endif
3732 return 1;
3733 event++;
3734 if (event == kbd_buffer + KBD_BUFFER_SIZE)
3735 event = kbd_buffer;
3737 while (event != kbd_store_ptr);
3739 else
3740 return 1;
3743 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3744 if (!(flags & READABLE_EVENTS_IGNORE_SQUEEZABLES)
3745 && !NILP (do_mouse_tracking) && some_mouse_moved ())
3746 return 1;
3747 #endif
3748 if (single_kboard)
3750 if (current_kboard->kbd_queue_has_data)
3751 return 1;
3753 else
3755 KBOARD *kb;
3756 for (kb = all_kboards; kb; kb = kb->next_kboard)
3757 if (kb->kbd_queue_has_data)
3758 return 1;
3760 return 0;
3763 /* Set this for debugging, to have a way to get out */
3764 int stop_character;
3766 static KBOARD *
3767 event_to_kboard (event)
3768 struct input_event *event;
3770 Lisp_Object frame;
3771 frame = event->frame_or_window;
3772 if (CONSP (frame))
3773 frame = XCAR (frame);
3774 else if (WINDOWP (frame))
3775 frame = WINDOW_FRAME (XWINDOW (frame));
3777 /* There are still some events that don't set this field.
3778 For now, just ignore the problem.
3779 Also ignore dead frames here. */
3780 if (!FRAMEP (frame) || !FRAME_LIVE_P (XFRAME (frame)))
3781 return 0;
3782 else
3783 return FRAME_KBOARD (XFRAME (frame));
3786 #ifdef subprocesses
3787 /* Return the number of slots occupied in kbd_buffer. */
3789 static int
3790 kbd_buffer_nr_stored (void)
3792 return kbd_fetch_ptr == kbd_store_ptr
3794 : (kbd_fetch_ptr < kbd_store_ptr
3795 ? kbd_store_ptr - kbd_fetch_ptr
3796 : ((kbd_buffer + KBD_BUFFER_SIZE) - kbd_fetch_ptr
3797 + (kbd_store_ptr - kbd_buffer)));
3799 #endif /* subprocesses */
3801 Lisp_Object Vthrow_on_input;
3803 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3805 void
3806 kbd_buffer_store_event (event)
3807 register struct input_event *event;
3809 kbd_buffer_store_event_hold (event, 0);
3812 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3814 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3815 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3816 Else, if EVENT is a quit event, store the quit event
3817 in HOLD_QUIT, and return (thus ignoring further events).
3819 This is used in read_avail_input to postpone the processing
3820 of the quit event until all subsequent input events have been
3821 parsed (and discarded).
3824 void
3825 kbd_buffer_store_event_hold (event, hold_quit)
3826 register struct input_event *event;
3827 struct input_event *hold_quit;
3829 if (event->kind == NO_EVENT)
3830 abort ();
3832 if (hold_quit && hold_quit->kind != NO_EVENT)
3833 return;
3835 if (event->kind == ASCII_KEYSTROKE_EVENT)
3837 register int c = event->code & 0377;
3839 if (event->modifiers & ctrl_modifier)
3840 c = make_ctrl_char (c);
3842 c |= (event->modifiers
3843 & (meta_modifier | alt_modifier
3844 | hyper_modifier | super_modifier));
3846 if (c == quit_char)
3848 KBOARD *kb = FRAME_KBOARD (XFRAME (event->frame_or_window));
3849 struct input_event *sp;
3851 if (single_kboard && kb != current_kboard)
3853 kb->kbd_queue
3854 = Fcons (make_lispy_switch_frame (event->frame_or_window),
3855 Fcons (make_number (c), Qnil));
3856 kb->kbd_queue_has_data = 1;
3857 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3859 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3860 sp = kbd_buffer;
3862 if (event_to_kboard (sp) == kb)
3864 sp->kind = NO_EVENT;
3865 sp->frame_or_window = Qnil;
3866 sp->arg = Qnil;
3869 return;
3872 if (hold_quit)
3874 bcopy (event, (char *) hold_quit, sizeof (*event));
3875 return;
3878 /* If this results in a quit_char being returned to Emacs as
3879 input, set Vlast_event_frame properly. If this doesn't
3880 get returned to Emacs as an event, the next event read
3881 will set Vlast_event_frame again, so this is safe to do. */
3883 Lisp_Object focus;
3885 focus = FRAME_FOCUS_FRAME (XFRAME (event->frame_or_window));
3886 if (NILP (focus))
3887 focus = event->frame_or_window;
3888 internal_last_event_frame = focus;
3889 Vlast_event_frame = focus;
3892 last_event_timestamp = event->timestamp;
3893 handle_interrupt ();
3894 return;
3897 if (c && c == stop_character)
3899 sys_suspend ();
3900 return;
3903 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3904 Just ignore the second one. */
3905 else if (event->kind == BUFFER_SWITCH_EVENT
3906 && kbd_fetch_ptr != kbd_store_ptr
3907 && ((kbd_store_ptr == kbd_buffer
3908 ? kbd_buffer + KBD_BUFFER_SIZE - 1
3909 : kbd_store_ptr - 1)->kind) == BUFFER_SWITCH_EVENT)
3910 return;
3912 if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
3913 kbd_store_ptr = kbd_buffer;
3915 /* Don't let the very last slot in the buffer become full,
3916 since that would make the two pointers equal,
3917 and that is indistinguishable from an empty buffer.
3918 Discard the event if it would fill the last slot. */
3919 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
3921 *kbd_store_ptr = *event;
3922 ++kbd_store_ptr;
3923 #ifdef subprocesses
3924 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE/2 && ! kbd_on_hold_p ())
3926 /* Don't read keyboard input until we have processed kbd_buffer.
3927 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3928 hold_keyboard_input ();
3929 #ifdef SIGIO
3930 if (!noninteractive)
3931 signal (SIGIO, SIG_IGN);
3932 #endif
3933 stop_polling ();
3935 #endif /* subprocesses */
3938 /* If we're inside while-no-input, and this event qualifies
3939 as input, set quit-flag to cause an interrupt. */
3940 if (!NILP (Vthrow_on_input)
3941 && event->kind != FOCUS_IN_EVENT
3942 && event->kind != HELP_EVENT
3943 && event->kind != DEICONIFY_EVENT)
3945 Vquit_flag = Vthrow_on_input;
3946 /* If we're inside a function that wants immediate quits,
3947 do it now. */
3948 if (immediate_quit && NILP (Vinhibit_quit))
3950 immediate_quit = 0;
3951 sigfree ();
3952 QUIT;
3958 /* Put an input event back in the head of the event queue. */
3960 void
3961 kbd_buffer_unget_event (event)
3962 register struct input_event *event;
3964 if (kbd_fetch_ptr == kbd_buffer)
3965 kbd_fetch_ptr = kbd_buffer + KBD_BUFFER_SIZE;
3967 /* Don't let the very last slot in the buffer become full, */
3968 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
3970 --kbd_fetch_ptr;
3971 *kbd_fetch_ptr = *event;
3976 /* Generate HELP_EVENT input_events in BUFP which has room for
3977 SIZE events. If there's not enough room in BUFP, ignore this
3978 event.
3980 HELP is the help form.
3982 FRAME is the frame on which the help is generated. OBJECT is the
3983 Lisp object where the help was found (a buffer, a string, an
3984 overlay, or nil if neither from a string nor from a buffer. POS is
3985 the position within OBJECT where the help was found.
3987 Value is the number of input_events generated. */
3989 void
3990 gen_help_event (help, frame, window, object, pos)
3991 Lisp_Object help, frame, object, window;
3992 int pos;
3994 struct input_event event;
3996 EVENT_INIT (event);
3998 event.kind = HELP_EVENT;
3999 event.frame_or_window = frame;
4000 event.arg = object;
4001 event.x = WINDOWP (window) ? window : frame;
4002 event.y = help;
4003 event.code = pos;
4004 kbd_buffer_store_event (&event);
4008 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
4010 void
4011 kbd_buffer_store_help_event (frame, help)
4012 Lisp_Object frame, help;
4014 struct input_event event;
4016 event.kind = HELP_EVENT;
4017 event.frame_or_window = frame;
4018 event.arg = Qnil;
4019 event.x = Qnil;
4020 event.y = help;
4021 event.code = 0;
4022 kbd_buffer_store_event (&event);
4026 /* Discard any mouse events in the event buffer by setting them to
4027 NO_EVENT. */
4028 void
4029 discard_mouse_events ()
4031 struct input_event *sp;
4032 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
4034 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
4035 sp = kbd_buffer;
4037 if (sp->kind == MOUSE_CLICK_EVENT
4038 || sp->kind == WHEEL_EVENT
4039 || sp->kind == HORIZ_WHEEL_EVENT
4040 #ifdef HAVE_GPM
4041 || sp->kind == GPM_CLICK_EVENT
4042 #endif
4043 || sp->kind == SCROLL_BAR_CLICK_EVENT)
4045 sp->kind = NO_EVENT;
4051 /* Return non-zero if there are any real events waiting in the event
4052 buffer, not counting `NO_EVENT's.
4054 If DISCARD is non-zero, discard NO_EVENT events at the front of
4055 the input queue, possibly leaving the input queue empty if there
4056 are no real input events. */
4059 kbd_buffer_events_waiting (discard)
4060 int discard;
4062 struct input_event *sp;
4064 for (sp = kbd_fetch_ptr;
4065 sp != kbd_store_ptr && sp->kind == NO_EVENT;
4066 ++sp)
4068 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
4069 sp = kbd_buffer;
4072 if (discard)
4073 kbd_fetch_ptr = sp;
4075 return sp != kbd_store_ptr && sp->kind != NO_EVENT;
4079 /* Clear input event EVENT. */
4081 static INLINE void
4082 clear_event (event)
4083 struct input_event *event;
4085 event->kind = NO_EVENT;
4089 /* Read one event from the event buffer, waiting if necessary.
4090 The value is a Lisp object representing the event.
4091 The value is nil for an event that should be ignored,
4092 or that was handled here.
4093 We always read and discard one event. */
4095 static Lisp_Object
4096 kbd_buffer_get_event (kbp, used_mouse_menu, end_time)
4097 KBOARD **kbp;
4098 int *used_mouse_menu;
4099 EMACS_TIME *end_time;
4101 register int c;
4102 Lisp_Object obj;
4104 #ifdef subprocesses
4105 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE/4)
4107 /* Start reading input again, we have processed enough so we can
4108 accept new events again. */
4109 unhold_keyboard_input ();
4110 #ifdef SIGIO
4111 if (!noninteractive)
4112 signal (SIGIO, input_available_signal);
4113 #endif /* SIGIO */
4114 start_polling ();
4116 #endif /* subprocesses */
4118 if (noninteractive
4119 /* In case we are running as a daemon, only do this before
4120 detaching from the terminal. */
4121 || (IS_DAEMON && daemon_pipe[1] >= 0))
4123 c = getchar ();
4124 XSETINT (obj, c);
4125 *kbp = current_kboard;
4126 return obj;
4129 /* Wait until there is input available. */
4130 for (;;)
4132 /* Break loop if there's an unread command event. Needed in
4133 moused window autoselection which uses a timer to insert such
4134 events. */
4135 if (CONSP (Vunread_command_events))
4136 break;
4138 if (kbd_fetch_ptr != kbd_store_ptr)
4139 break;
4140 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4141 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
4142 break;
4143 #endif
4145 /* If the quit flag is set, then read_char will return
4146 quit_char, so that counts as "available input." */
4147 if (!NILP (Vquit_flag))
4148 quit_throw_to_read_char ();
4150 /* One way or another, wait until input is available; then, if
4151 interrupt handlers have not read it, read it now. */
4153 #ifdef HAVE_DBUS
4154 /* Read D-Bus messages. */
4155 xd_read_queued_messages ();
4156 #endif /* HAVE_DBUS */
4158 /* Note SIGIO has been undef'd if FIONREAD is missing. */
4159 #ifdef SIGIO
4160 gobble_input (0);
4161 #endif /* SIGIO */
4162 if (kbd_fetch_ptr != kbd_store_ptr)
4163 break;
4164 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4165 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
4166 break;
4167 #endif
4168 if (end_time)
4170 EMACS_TIME duration;
4171 EMACS_GET_TIME (duration);
4172 if (EMACS_TIME_GE (duration, *end_time))
4173 return Qnil; /* finished waiting */
4174 else
4176 EMACS_SUB_TIME (duration, *end_time, duration);
4177 wait_reading_process_output (EMACS_SECS (duration),
4178 EMACS_USECS (duration),
4179 -1, 1, Qnil, NULL, 0);
4182 else
4183 wait_reading_process_output (0, 0, -1, 1, Qnil, NULL, 0);
4185 if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
4186 /* Pass 1 for EXPECT since we just waited to have input. */
4187 read_avail_input (1);
4190 if (CONSP (Vunread_command_events))
4192 Lisp_Object first;
4193 first = XCAR (Vunread_command_events);
4194 Vunread_command_events = XCDR (Vunread_command_events);
4195 *kbp = current_kboard;
4196 return first;
4199 /* At this point, we know that there is a readable event available
4200 somewhere. If the event queue is empty, then there must be a
4201 mouse movement enabled and available. */
4202 if (kbd_fetch_ptr != kbd_store_ptr)
4204 struct input_event *event;
4206 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
4207 ? kbd_fetch_ptr
4208 : kbd_buffer);
4210 last_event_timestamp = event->timestamp;
4212 *kbp = event_to_kboard (event);
4213 if (*kbp == 0)
4214 *kbp = current_kboard; /* Better than returning null ptr? */
4216 obj = Qnil;
4218 /* These two kinds of events get special handling
4219 and don't actually appear to the command loop.
4220 We return nil for them. */
4221 if (event->kind == SELECTION_REQUEST_EVENT
4222 || event->kind == SELECTION_CLEAR_EVENT)
4224 #ifdef HAVE_X11
4225 struct input_event copy;
4227 /* Remove it from the buffer before processing it,
4228 since otherwise swallow_events will see it
4229 and process it again. */
4230 copy = *event;
4231 kbd_fetch_ptr = event + 1;
4232 input_pending = readable_events (0);
4233 x_handle_selection_event (&copy);
4234 #else
4235 /* We're getting selection request events, but we don't have
4236 a window system. */
4237 abort ();
4238 #endif
4241 #if defined (HAVE_NS)
4242 else if (event->kind == NS_TEXT_EVENT)
4244 if (event->code == KEY_NS_PUT_WORKING_TEXT)
4245 obj = Fcons (intern ("ns-put-working-text"), Qnil);
4246 else
4247 obj = Fcons (intern ("ns-unput-working-text"), Qnil);
4248 kbd_fetch_ptr = event + 1;
4249 if (used_mouse_menu)
4250 *used_mouse_menu = 1;
4252 #endif
4254 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4255 || defined (HAVE_NS)
4256 else if (event->kind == DELETE_WINDOW_EVENT)
4258 /* Make an event (delete-frame (FRAME)). */
4259 obj = Fcons (event->frame_or_window, Qnil);
4260 obj = Fcons (Qdelete_frame, Fcons (obj, Qnil));
4261 kbd_fetch_ptr = event + 1;
4263 #endif
4264 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4265 || defined (HAVE_NS)
4266 else if (event->kind == ICONIFY_EVENT)
4268 /* Make an event (iconify-frame (FRAME)). */
4269 obj = Fcons (event->frame_or_window, Qnil);
4270 obj = Fcons (Qiconify_frame, Fcons (obj, Qnil));
4271 kbd_fetch_ptr = event + 1;
4273 else if (event->kind == DEICONIFY_EVENT)
4275 /* Make an event (make-frame-visible (FRAME)). */
4276 obj = Fcons (event->frame_or_window, Qnil);
4277 obj = Fcons (Qmake_frame_visible, Fcons (obj, Qnil));
4278 kbd_fetch_ptr = event + 1;
4280 #endif
4281 else if (event->kind == BUFFER_SWITCH_EVENT)
4283 /* The value doesn't matter here; only the type is tested. */
4284 XSETBUFFER (obj, current_buffer);
4285 kbd_fetch_ptr = event + 1;
4287 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4288 || defined(HAVE_NS) || defined (USE_GTK)
4289 else if (event->kind == MENU_BAR_ACTIVATE_EVENT)
4291 kbd_fetch_ptr = event + 1;
4292 input_pending = readable_events (0);
4293 if (FRAME_LIVE_P (XFRAME (event->frame_or_window)))
4294 x_activate_menubar (XFRAME (event->frame_or_window));
4296 #endif
4297 #if defined (WINDOWSNT)
4298 else if (event->kind == LANGUAGE_CHANGE_EVENT)
4300 /* Make an event (language-change (FRAME CHARSET LCID)). */
4301 obj = Fcons (event->frame_or_window, Qnil);
4302 obj = Fcons (Qlanguage_change, Fcons (obj, Qnil));
4303 kbd_fetch_ptr = event + 1;
4305 #endif
4306 else if (event->kind == SAVE_SESSION_EVENT)
4308 obj = Fcons (Qsave_session, Fcons (event->arg, Qnil));
4309 kbd_fetch_ptr = event + 1;
4311 /* Just discard these, by returning nil.
4312 With MULTI_KBOARD, these events are used as placeholders
4313 when we need to randomly delete events from the queue.
4314 (They shouldn't otherwise be found in the buffer,
4315 but on some machines it appears they do show up
4316 even without MULTI_KBOARD.) */
4317 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4318 mouse events during a popup-menu call. */
4319 else if (event->kind == NO_EVENT)
4320 kbd_fetch_ptr = event + 1;
4321 else if (event->kind == HELP_EVENT)
4323 Lisp_Object object, position, help, frame, window;
4325 frame = event->frame_or_window;
4326 object = event->arg;
4327 position = make_number (event->code);
4328 window = event->x;
4329 help = event->y;
4330 clear_event (event);
4332 kbd_fetch_ptr = event + 1;
4333 if (!WINDOWP (window))
4334 window = Qnil;
4335 obj = Fcons (Qhelp_echo,
4336 list5 (frame, help, window, object, position));
4338 else if (event->kind == FOCUS_IN_EVENT)
4340 /* Notification of a FocusIn event. The frame receiving the
4341 focus is in event->frame_or_window. Generate a
4342 switch-frame event if necessary. */
4343 Lisp_Object frame, focus;
4345 frame = event->frame_or_window;
4346 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
4347 if (FRAMEP (focus))
4348 frame = focus;
4350 if (!EQ (frame, internal_last_event_frame)
4351 && !EQ (frame, selected_frame))
4352 obj = make_lispy_switch_frame (frame);
4353 internal_last_event_frame = frame;
4354 kbd_fetch_ptr = event + 1;
4356 #ifdef HAVE_DBUS
4357 else if (event->kind == DBUS_EVENT)
4359 obj = make_lispy_event (event);
4360 kbd_fetch_ptr = event + 1;
4362 #endif
4363 else if (event->kind == CONFIG_CHANGED_EVENT)
4365 obj = make_lispy_event (event);
4366 kbd_fetch_ptr = event + 1;
4368 else
4370 /* If this event is on a different frame, return a switch-frame this
4371 time, and leave the event in the queue for next time. */
4372 Lisp_Object frame;
4373 Lisp_Object focus;
4375 frame = event->frame_or_window;
4376 if (CONSP (frame))
4377 frame = XCAR (frame);
4378 else if (WINDOWP (frame))
4379 frame = WINDOW_FRAME (XWINDOW (frame));
4381 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
4382 if (! NILP (focus))
4383 frame = focus;
4385 if (! EQ (frame, internal_last_event_frame)
4386 && !EQ (frame, selected_frame))
4387 obj = make_lispy_switch_frame (frame);
4388 internal_last_event_frame = frame;
4390 /* If we didn't decide to make a switch-frame event, go ahead
4391 and build a real event from the queue entry. */
4393 if (NILP (obj))
4395 obj = make_lispy_event (event);
4397 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4398 || defined(HAVE_NS) || defined (USE_GTK)
4399 /* If this was a menu selection, then set the flag to inhibit
4400 writing to last_nonmenu_event. Don't do this if the event
4401 we're returning is (menu-bar), though; that indicates the
4402 beginning of the menu sequence, and we might as well leave
4403 that as the `event with parameters' for this selection. */
4404 if (used_mouse_menu
4405 && !EQ (event->frame_or_window, event->arg)
4406 && (event->kind == MENU_BAR_EVENT
4407 || event->kind == TOOL_BAR_EVENT))
4408 *used_mouse_menu = 1;
4409 #endif
4410 #ifdef HAVE_NS
4411 /* certain system events are non-key events */
4412 if (used_mouse_menu
4413 && event->kind == NS_NONKEY_EVENT)
4414 *used_mouse_menu = 1;
4415 #endif
4417 /* Wipe out this event, to catch bugs. */
4418 clear_event (event);
4419 kbd_fetch_ptr = event + 1;
4423 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4424 /* Try generating a mouse motion event. */
4425 else if (!NILP (do_mouse_tracking) && some_mouse_moved ())
4427 FRAME_PTR f = some_mouse_moved ();
4428 Lisp_Object bar_window;
4429 enum scroll_bar_part part;
4430 Lisp_Object x, y;
4431 unsigned long time;
4433 *kbp = current_kboard;
4434 /* Note that this uses F to determine which terminal to look at.
4435 If there is no valid info, it does not store anything
4436 so x remains nil. */
4437 x = Qnil;
4439 /* XXX Can f or mouse_position_hook be NULL here? */
4440 if (f && FRAME_TERMINAL (f)->mouse_position_hook)
4441 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, 0, &bar_window,
4442 &part, &x, &y, &time);
4444 obj = Qnil;
4446 /* Decide if we should generate a switch-frame event. Don't
4447 generate switch-frame events for motion outside of all Emacs
4448 frames. */
4449 if (!NILP (x) && f)
4451 Lisp_Object frame;
4453 frame = FRAME_FOCUS_FRAME (f);
4454 if (NILP (frame))
4455 XSETFRAME (frame, f);
4457 if (! EQ (frame, internal_last_event_frame)
4458 && !EQ (frame, selected_frame))
4459 obj = make_lispy_switch_frame (frame);
4460 internal_last_event_frame = frame;
4463 /* If we didn't decide to make a switch-frame event, go ahead and
4464 return a mouse-motion event. */
4465 if (!NILP (x) && NILP (obj))
4466 obj = make_lispy_movement (f, bar_window, part, x, y, time);
4468 #endif /* HAVE_MOUSE || HAVE GPM */
4469 else
4470 /* We were promised by the above while loop that there was
4471 something for us to read! */
4472 abort ();
4474 input_pending = readable_events (0);
4476 Vlast_event_frame = internal_last_event_frame;
4478 return (obj);
4481 /* Process any events that are not user-visible,
4482 then return, without reading any user-visible events. */
4484 void
4485 swallow_events (do_display)
4486 int do_display;
4488 int old_timers_run;
4490 while (kbd_fetch_ptr != kbd_store_ptr)
4492 struct input_event *event;
4494 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
4495 ? kbd_fetch_ptr
4496 : kbd_buffer);
4498 last_event_timestamp = event->timestamp;
4500 /* These two kinds of events get special handling
4501 and don't actually appear to the command loop. */
4502 if (event->kind == SELECTION_REQUEST_EVENT
4503 || event->kind == SELECTION_CLEAR_EVENT)
4505 #ifdef HAVE_X11
4506 struct input_event copy;
4508 /* Remove it from the buffer before processing it,
4509 since otherwise swallow_events called recursively could see it
4510 and process it again. */
4511 copy = *event;
4512 kbd_fetch_ptr = event + 1;
4513 input_pending = readable_events (0);
4514 x_handle_selection_event (&copy);
4515 #else
4516 /* We're getting selection request events, but we don't have
4517 a window system. */
4518 abort ();
4519 #endif
4521 else
4522 break;
4525 old_timers_run = timers_run;
4526 get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
4528 if (timers_run != old_timers_run && do_display)
4529 redisplay_preserve_echo_area (7);
4532 /* Record the start of when Emacs is idle,
4533 for the sake of running idle-time timers. */
4535 static void
4536 timer_start_idle ()
4538 Lisp_Object timers;
4540 /* If we are already in the idle state, do nothing. */
4541 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4542 return;
4544 EMACS_GET_TIME (timer_idleness_start_time);
4546 timer_last_idleness_start_time = timer_idleness_start_time;
4548 /* Mark all idle-time timers as once again candidates for running. */
4549 for (timers = Vtimer_idle_list; CONSP (timers); timers = XCDR (timers))
4551 Lisp_Object timer;
4553 timer = XCAR (timers);
4555 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4556 continue;
4557 XVECTOR (timer)->contents[0] = Qnil;
4561 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4563 static void
4564 timer_stop_idle ()
4566 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
4569 /* Resume idle timer from last idle start time. */
4571 static void
4572 timer_resume_idle ()
4574 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4575 return;
4577 timer_idleness_start_time = timer_last_idleness_start_time;
4580 /* This is only for debugging. */
4581 struct input_event last_timer_event;
4583 /* List of elisp functions to call, delayed because they were generated in
4584 a context where Elisp could not be safely run (e.g. redisplay, signal,
4585 ...). Each element has the form (FUN . ARGS). */
4586 Lisp_Object pending_funcalls;
4588 extern Lisp_Object Qapply;
4590 /* Check whether a timer has fired. To prevent larger problems we simply
4591 disregard elements that are not proper timers. Do not make a circular
4592 timer list for the time being.
4594 Returns the time to wait until the next timer fires. If a
4595 timer is triggering now, return zero.
4596 If no timer is active, return -1.
4598 If a timer is ripe, we run it, with quitting turned off.
4599 In that case we return 0 to indicate that a new timer_check_2 call
4600 should be done. */
4602 static EMACS_TIME
4603 timer_check_2 ()
4605 EMACS_TIME nexttime;
4606 EMACS_TIME now, idleness_now;
4607 Lisp_Object timers, idle_timers, chosen_timer;
4608 struct gcpro gcpro1, gcpro2, gcpro3;
4610 EMACS_SET_SECS (nexttime, -1);
4611 EMACS_SET_USECS (nexttime, -1);
4613 /* Always consider the ordinary timers. */
4614 timers = Vtimer_list;
4615 /* Consider the idle timers only if Emacs is idle. */
4616 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4617 idle_timers = Vtimer_idle_list;
4618 else
4619 idle_timers = Qnil;
4620 chosen_timer = Qnil;
4621 GCPRO3 (timers, idle_timers, chosen_timer);
4623 /* First run the code that was delayed. */
4624 while (CONSP (pending_funcalls))
4626 Lisp_Object funcall = XCAR (pending_funcalls);
4627 pending_funcalls = XCDR (pending_funcalls);
4628 safe_call2 (Qapply, XCAR (funcall), XCDR (funcall));
4631 if (CONSP (timers) || CONSP (idle_timers))
4633 EMACS_GET_TIME (now);
4634 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4635 EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
4638 while (CONSP (timers) || CONSP (idle_timers))
4640 Lisp_Object *vector;
4641 Lisp_Object timer = Qnil, idle_timer = Qnil;
4642 EMACS_TIME timer_time, idle_timer_time;
4643 EMACS_TIME difference, timer_difference, idle_timer_difference;
4645 /* Skip past invalid timers and timers already handled. */
4646 if (!NILP (timers))
4648 timer = XCAR (timers);
4649 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4651 timers = XCDR (timers);
4652 continue;
4654 vector = XVECTOR (timer)->contents;
4656 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
4657 || !INTEGERP (vector[3])
4658 || ! NILP (vector[0]))
4660 timers = XCDR (timers);
4661 continue;
4664 if (!NILP (idle_timers))
4666 timer = XCAR (idle_timers);
4667 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4669 idle_timers = XCDR (idle_timers);
4670 continue;
4672 vector = XVECTOR (timer)->contents;
4674 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
4675 || !INTEGERP (vector[3])
4676 || ! NILP (vector[0]))
4678 idle_timers = XCDR (idle_timers);
4679 continue;
4683 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4684 based on the next ordinary timer.
4685 TIMER_DIFFERENCE is the distance in time from NOW to when
4686 this timer becomes ripe (negative if it's already ripe). */
4687 if (!NILP (timers))
4689 timer = XCAR (timers);
4690 vector = XVECTOR (timer)->contents;
4691 EMACS_SET_SECS (timer_time,
4692 (XINT (vector[1]) << 16) | (XINT (vector[2])));
4693 EMACS_SET_USECS (timer_time, XINT (vector[3]));
4694 EMACS_SUB_TIME (timer_difference, timer_time, now);
4697 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4698 based on the next idle timer. */
4699 if (!NILP (idle_timers))
4701 idle_timer = XCAR (idle_timers);
4702 vector = XVECTOR (idle_timer)->contents;
4703 EMACS_SET_SECS (idle_timer_time,
4704 (XINT (vector[1]) << 16) | (XINT (vector[2])));
4705 EMACS_SET_USECS (idle_timer_time, XINT (vector[3]));
4706 EMACS_SUB_TIME (idle_timer_difference, idle_timer_time, idleness_now);
4709 /* Decide which timer is the next timer,
4710 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4711 Also step down the list where we found that timer. */
4713 if (! NILP (timers) && ! NILP (idle_timers))
4715 EMACS_TIME temp;
4716 EMACS_SUB_TIME (temp, timer_difference, idle_timer_difference);
4717 if (EMACS_TIME_NEG_P (temp))
4719 chosen_timer = timer;
4720 timers = XCDR (timers);
4721 difference = timer_difference;
4723 else
4725 chosen_timer = idle_timer;
4726 idle_timers = XCDR (idle_timers);
4727 difference = idle_timer_difference;
4730 else if (! NILP (timers))
4732 chosen_timer = timer;
4733 timers = XCDR (timers);
4734 difference = timer_difference;
4736 else
4738 chosen_timer = idle_timer;
4739 idle_timers = XCDR (idle_timers);
4740 difference = idle_timer_difference;
4742 vector = XVECTOR (chosen_timer)->contents;
4744 /* If timer is ripe, run it if it hasn't been run. */
4745 if (EMACS_TIME_NEG_P (difference)
4746 || (EMACS_SECS (difference) == 0
4747 && EMACS_USECS (difference) == 0))
4749 if (NILP (vector[0]))
4751 int count = SPECPDL_INDEX ();
4752 Lisp_Object old_deactivate_mark = Vdeactivate_mark;
4754 /* Mark the timer as triggered to prevent problems if the lisp
4755 code fails to reschedule it right. */
4756 vector[0] = Qt;
4758 specbind (Qinhibit_quit, Qt);
4760 call1 (Qtimer_event_handler, chosen_timer);
4761 Vdeactivate_mark = old_deactivate_mark;
4762 timers_run++;
4763 unbind_to (count, Qnil);
4765 /* Since we have handled the event,
4766 we don't need to tell the caller to wake up and do it. */
4767 /* But the caller must still wait for the next timer, so
4768 return 0 to indicate that. */
4771 EMACS_SET_SECS (nexttime, 0);
4772 EMACS_SET_USECS (nexttime, 0);
4774 else
4775 /* When we encounter a timer that is still waiting,
4776 return the amount of time to wait before it is ripe. */
4778 UNGCPRO;
4779 return difference;
4783 /* No timers are pending in the future. */
4784 /* Return 0 if we generated an event, and -1 if not. */
4785 UNGCPRO;
4786 return nexttime;
4790 /* Check whether a timer has fired. To prevent larger problems we simply
4791 disregard elements that are not proper timers. Do not make a circular
4792 timer list for the time being.
4794 Returns the time to wait until the next timer fires.
4795 If no timer is active, return -1.
4797 As long as any timer is ripe, we run it.
4799 DO_IT_NOW is now ignored. It used to mean that we should
4800 run the timer directly instead of queueing a timer-event.
4801 Now we always run timers directly. */
4803 EMACS_TIME
4804 timer_check (do_it_now)
4805 int do_it_now;
4807 EMACS_TIME nexttime;
4811 nexttime = timer_check_2 ();
4813 while (EMACS_SECS (nexttime) == 0 && EMACS_USECS (nexttime) == 0);
4815 return nexttime;
4818 DEFUN ("current-idle-time", Fcurrent_idle_time, Scurrent_idle_time, 0, 0, 0,
4819 doc: /* Return the current length of Emacs idleness, or nil.
4820 The value when Emacs is idle is a list of three integers. The first has
4821 the most significant 16 bits of the seconds, while the second has the least
4822 significant 16 bits. The third integer gives the microsecond count.
4824 The value when Emacs is not idle is nil.
4826 The microsecond count is zero on systems that do not provide
4827 resolution finer than a second. */)
4830 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4832 EMACS_TIME now, idleness_now;
4834 EMACS_GET_TIME (now);
4835 EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
4837 return list3 (make_number ((EMACS_SECS (idleness_now) >> 16) & 0xffff),
4838 make_number ((EMACS_SECS (idleness_now) >> 0) & 0xffff),
4839 make_number (EMACS_USECS (idleness_now)));
4842 return Qnil;
4845 /* Caches for modify_event_symbol. */
4846 static Lisp_Object accent_key_syms;
4847 static Lisp_Object func_key_syms;
4848 static Lisp_Object mouse_syms;
4849 static Lisp_Object wheel_syms;
4850 static Lisp_Object drag_n_drop_syms;
4852 /* This is a list of keysym codes for special "accent" characters.
4853 It parallels lispy_accent_keys. */
4855 static const int lispy_accent_codes[] =
4857 #ifdef XK_dead_circumflex
4858 XK_dead_circumflex,
4859 #else
4861 #endif
4862 #ifdef XK_dead_grave
4863 XK_dead_grave,
4864 #else
4866 #endif
4867 #ifdef XK_dead_tilde
4868 XK_dead_tilde,
4869 #else
4871 #endif
4872 #ifdef XK_dead_diaeresis
4873 XK_dead_diaeresis,
4874 #else
4876 #endif
4877 #ifdef XK_dead_macron
4878 XK_dead_macron,
4879 #else
4881 #endif
4882 #ifdef XK_dead_degree
4883 XK_dead_degree,
4884 #else
4886 #endif
4887 #ifdef XK_dead_acute
4888 XK_dead_acute,
4889 #else
4891 #endif
4892 #ifdef XK_dead_cedilla
4893 XK_dead_cedilla,
4894 #else
4896 #endif
4897 #ifdef XK_dead_breve
4898 XK_dead_breve,
4899 #else
4901 #endif
4902 #ifdef XK_dead_ogonek
4903 XK_dead_ogonek,
4904 #else
4906 #endif
4907 #ifdef XK_dead_caron
4908 XK_dead_caron,
4909 #else
4911 #endif
4912 #ifdef XK_dead_doubleacute
4913 XK_dead_doubleacute,
4914 #else
4916 #endif
4917 #ifdef XK_dead_abovedot
4918 XK_dead_abovedot,
4919 #else
4921 #endif
4922 #ifdef XK_dead_abovering
4923 XK_dead_abovering,
4924 #else
4926 #endif
4927 #ifdef XK_dead_iota
4928 XK_dead_iota,
4929 #else
4931 #endif
4932 #ifdef XK_dead_belowdot
4933 XK_dead_belowdot,
4934 #else
4936 #endif
4937 #ifdef XK_dead_voiced_sound
4938 XK_dead_voiced_sound,
4939 #else
4941 #endif
4942 #ifdef XK_dead_semivoiced_sound
4943 XK_dead_semivoiced_sound,
4944 #else
4946 #endif
4947 #ifdef XK_dead_hook
4948 XK_dead_hook,
4949 #else
4951 #endif
4952 #ifdef XK_dead_horn
4953 XK_dead_horn,
4954 #else
4956 #endif
4959 /* This is a list of Lisp names for special "accent" characters.
4960 It parallels lispy_accent_codes. */
4962 static char *lispy_accent_keys[] =
4964 "dead-circumflex",
4965 "dead-grave",
4966 "dead-tilde",
4967 "dead-diaeresis",
4968 "dead-macron",
4969 "dead-degree",
4970 "dead-acute",
4971 "dead-cedilla",
4972 "dead-breve",
4973 "dead-ogonek",
4974 "dead-caron",
4975 "dead-doubleacute",
4976 "dead-abovedot",
4977 "dead-abovering",
4978 "dead-iota",
4979 "dead-belowdot",
4980 "dead-voiced-sound",
4981 "dead-semivoiced-sound",
4982 "dead-hook",
4983 "dead-horn",
4986 #ifdef HAVE_NTGUI
4987 #define FUNCTION_KEY_OFFSET 0x0
4989 char *lispy_function_keys[] =
4991 0, /* 0 */
4993 0, /* VK_LBUTTON 0x01 */
4994 0, /* VK_RBUTTON 0x02 */
4995 "cancel", /* VK_CANCEL 0x03 */
4996 0, /* VK_MBUTTON 0x04 */
4998 0, 0, 0, /* 0x05 .. 0x07 */
5000 "backspace", /* VK_BACK 0x08 */
5001 "tab", /* VK_TAB 0x09 */
5003 0, 0, /* 0x0A .. 0x0B */
5005 "clear", /* VK_CLEAR 0x0C */
5006 "return", /* VK_RETURN 0x0D */
5008 0, 0, /* 0x0E .. 0x0F */
5010 0, /* VK_SHIFT 0x10 */
5011 0, /* VK_CONTROL 0x11 */
5012 0, /* VK_MENU 0x12 */
5013 "pause", /* VK_PAUSE 0x13 */
5014 "capslock", /* VK_CAPITAL 0x14 */
5015 "kana", /* VK_KANA/VK_HANGUL 0x15 */
5016 0, /* 0x16 */
5017 "junja", /* VK_JUNJA 0x17 */
5018 "final", /* VK_FINAL 0x18 */
5019 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
5020 0, /* 0x1A */
5021 "escape", /* VK_ESCAPE 0x1B */
5022 "convert", /* VK_CONVERT 0x1C */
5023 "non-convert", /* VK_NONCONVERT 0x1D */
5024 "accept", /* VK_ACCEPT 0x1E */
5025 "mode-change", /* VK_MODECHANGE 0x1F */
5026 0, /* VK_SPACE 0x20 */
5027 "prior", /* VK_PRIOR 0x21 */
5028 "next", /* VK_NEXT 0x22 */
5029 "end", /* VK_END 0x23 */
5030 "home", /* VK_HOME 0x24 */
5031 "left", /* VK_LEFT 0x25 */
5032 "up", /* VK_UP 0x26 */
5033 "right", /* VK_RIGHT 0x27 */
5034 "down", /* VK_DOWN 0x28 */
5035 "select", /* VK_SELECT 0x29 */
5036 "print", /* VK_PRINT 0x2A */
5037 "execute", /* VK_EXECUTE 0x2B */
5038 "snapshot", /* VK_SNAPSHOT 0x2C */
5039 "insert", /* VK_INSERT 0x2D */
5040 "delete", /* VK_DELETE 0x2E */
5041 "help", /* VK_HELP 0x2F */
5043 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
5045 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5047 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
5049 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
5051 0, 0, 0, 0, 0, 0, 0, 0, 0,
5052 0, 0, 0, 0, 0, 0, 0, 0, 0,
5053 0, 0, 0, 0, 0, 0, 0, 0,
5055 "lwindow", /* VK_LWIN 0x5B */
5056 "rwindow", /* VK_RWIN 0x5C */
5057 "apps", /* VK_APPS 0x5D */
5058 0, /* 0x5E */
5059 "sleep",
5060 "kp-0", /* VK_NUMPAD0 0x60 */
5061 "kp-1", /* VK_NUMPAD1 0x61 */
5062 "kp-2", /* VK_NUMPAD2 0x62 */
5063 "kp-3", /* VK_NUMPAD3 0x63 */
5064 "kp-4", /* VK_NUMPAD4 0x64 */
5065 "kp-5", /* VK_NUMPAD5 0x65 */
5066 "kp-6", /* VK_NUMPAD6 0x66 */
5067 "kp-7", /* VK_NUMPAD7 0x67 */
5068 "kp-8", /* VK_NUMPAD8 0x68 */
5069 "kp-9", /* VK_NUMPAD9 0x69 */
5070 "kp-multiply", /* VK_MULTIPLY 0x6A */
5071 "kp-add", /* VK_ADD 0x6B */
5072 "kp-separator", /* VK_SEPARATOR 0x6C */
5073 "kp-subtract", /* VK_SUBTRACT 0x6D */
5074 "kp-decimal", /* VK_DECIMAL 0x6E */
5075 "kp-divide", /* VK_DIVIDE 0x6F */
5076 "f1", /* VK_F1 0x70 */
5077 "f2", /* VK_F2 0x71 */
5078 "f3", /* VK_F3 0x72 */
5079 "f4", /* VK_F4 0x73 */
5080 "f5", /* VK_F5 0x74 */
5081 "f6", /* VK_F6 0x75 */
5082 "f7", /* VK_F7 0x76 */
5083 "f8", /* VK_F8 0x77 */
5084 "f9", /* VK_F9 0x78 */
5085 "f10", /* VK_F10 0x79 */
5086 "f11", /* VK_F11 0x7A */
5087 "f12", /* VK_F12 0x7B */
5088 "f13", /* VK_F13 0x7C */
5089 "f14", /* VK_F14 0x7D */
5090 "f15", /* VK_F15 0x7E */
5091 "f16", /* VK_F16 0x7F */
5092 "f17", /* VK_F17 0x80 */
5093 "f18", /* VK_F18 0x81 */
5094 "f19", /* VK_F19 0x82 */
5095 "f20", /* VK_F20 0x83 */
5096 "f21", /* VK_F21 0x84 */
5097 "f22", /* VK_F22 0x85 */
5098 "f23", /* VK_F23 0x86 */
5099 "f24", /* VK_F24 0x87 */
5101 0, 0, 0, 0, /* 0x88 .. 0x8B */
5102 0, 0, 0, 0, /* 0x8C .. 0x8F */
5104 "kp-numlock", /* VK_NUMLOCK 0x90 */
5105 "scroll", /* VK_SCROLL 0x91 */
5106 /* Not sure where the following block comes from.
5107 Windows headers have NEC and Fujitsu specific keys in
5108 this block, but nothing generic. */
5109 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
5110 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
5111 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
5112 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
5113 "kp-end", /* VK_NUMPAD_END 0x96 */
5114 "kp-home", /* VK_NUMPAD_HOME 0x97 */
5115 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
5116 "kp-up", /* VK_NUMPAD_UP 0x99 */
5117 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
5118 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
5119 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
5120 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
5122 0, 0, /* 0x9E .. 0x9F */
5125 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
5126 * Used only as parameters to GetAsyncKeyState and GetKeyState.
5127 * No other API or message will distinguish left and right keys this way.
5128 * 0xA0 .. 0xA5
5130 0, 0, 0, 0, 0, 0,
5132 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
5133 to enable them selectively, and gives access to a few more functions.
5134 See lispy_multimedia_keys below. */
5135 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
5136 0, 0, 0, /* 0xAD .. 0xAF Volume */
5137 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
5138 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
5140 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
5141 0, 0, 0, 0, 0, 0, 0, 0, 0,
5143 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
5144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5147 0, /* 0xE0 */
5148 "ax", /* VK_OEM_AX 0xE1 */
5149 0, /* VK_OEM_102 0xE2 */
5150 "ico-help", /* VK_ICO_HELP 0xE3 */
5151 "ico-00", /* VK_ICO_00 0xE4 */
5152 0, /* VK_PROCESSKEY 0xE5 */
5153 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
5154 "packet", /* VK_PACKET 0xE7 */
5155 0, /* 0xE8 */
5156 "reset", /* VK_OEM_RESET 0xE9 */
5157 "jump", /* VK_OEM_JUMP 0xEA */
5158 "oem-pa1", /* VK_OEM_PA1 0xEB */
5159 "oem-pa2", /* VK_OEM_PA2 0xEC */
5160 "oem-pa3", /* VK_OEM_PA3 0xED */
5161 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
5162 "cusel", /* VK_OEM_CUSEL 0xEF */
5163 "oem-attn", /* VK_OEM_ATTN 0xF0 */
5164 "finish", /* VK_OEM_FINISH 0xF1 */
5165 "copy", /* VK_OEM_COPY 0xF2 */
5166 "auto", /* VK_OEM_AUTO 0xF3 */
5167 "enlw", /* VK_OEM_ENLW 0xF4 */
5168 "backtab", /* VK_OEM_BACKTAB 0xF5 */
5169 "attn", /* VK_ATTN 0xF6 */
5170 "crsel", /* VK_CRSEL 0xF7 */
5171 "exsel", /* VK_EXSEL 0xF8 */
5172 "ereof", /* VK_EREOF 0xF9 */
5173 "play", /* VK_PLAY 0xFA */
5174 "zoom", /* VK_ZOOM 0xFB */
5175 "noname", /* VK_NONAME 0xFC */
5176 "pa1", /* VK_PA1 0xFD */
5177 "oem_clear", /* VK_OEM_CLEAR 0xFE */
5178 0 /* 0xFF */
5181 /* Some of these duplicate the "Media keys" on newer keyboards,
5182 but they are delivered to the application in a different way. */
5183 static char *lispy_multimedia_keys[] =
5186 "browser-back",
5187 "browser-forward",
5188 "browser-refresh",
5189 "browser-stop",
5190 "browser-search",
5191 "browser-favorites",
5192 "browser-home",
5193 "volume-mute",
5194 "volume-down",
5195 "volume-up",
5196 "media-next",
5197 "media-previous",
5198 "media-stop",
5199 "media-play-pause",
5200 "mail",
5201 "media-select",
5202 "app-1",
5203 "app-2",
5204 "bass-down",
5205 "bass-boost",
5206 "bass-up",
5207 "treble-down",
5208 "treble-up",
5209 "mic-volume-mute",
5210 "mic-volume-down",
5211 "mic-volume-up",
5212 "help",
5213 "find",
5214 "new",
5215 "open",
5216 "close",
5217 "save",
5218 "print",
5219 "undo",
5220 "redo",
5221 "copy",
5222 "cut",
5223 "paste",
5224 "mail-reply",
5225 "mail-forward",
5226 "mail-send",
5227 "spell-check",
5228 "toggle-dictate-command",
5229 "mic-toggle",
5230 "correction-list",
5231 "media-play",
5232 "media-pause",
5233 "media-record",
5234 "media-fast-forward",
5235 "media-rewind",
5236 "media-channel-up",
5237 "media-channel-down"
5240 #else /* not HAVE_NTGUI */
5242 /* This should be dealt with in XTread_socket now, and that doesn't
5243 depend on the client system having the Kana syms defined. See also
5244 the XK_kana_A case below. */
5245 #if 0
5246 #ifdef XK_kana_A
5247 static char *lispy_kana_keys[] =
5249 /* X Keysym value */
5250 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
5251 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
5252 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
5253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
5254 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
5255 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
5256 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
5257 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
5258 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
5259 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
5260 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
5261 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
5262 "kana-i", "kana-u", "kana-e", "kana-o",
5263 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
5264 "prolongedsound", "kana-A", "kana-I", "kana-U",
5265 "kana-E", "kana-O", "kana-KA", "kana-KI",
5266 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
5267 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
5268 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
5269 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
5270 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
5271 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
5272 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
5273 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
5274 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
5275 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
5276 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
5277 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
5279 #endif /* XK_kana_A */
5280 #endif /* 0 */
5282 #define FUNCTION_KEY_OFFSET 0xff00
5284 /* You'll notice that this table is arranged to be conveniently
5285 indexed by X Windows keysym values. */
5286 static char *lispy_function_keys[] =
5288 /* X Keysym value */
5290 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
5291 "backspace", "tab", "linefeed", "clear",
5292 0, "return", 0, 0,
5293 0, 0, 0, "pause", /* 0xff10...1f */
5294 0, 0, 0, 0, 0, 0, 0, "escape",
5295 0, 0, 0, 0,
5296 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
5297 "romaji", "hiragana", "katakana", "hiragana-katakana",
5298 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
5299 "massyo", "kana-lock", "kana-shift", "eisu-shift",
5300 "eisu-toggle", /* 0xff30...3f */
5301 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
5304 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
5305 "down", "prior", "next", "end",
5306 "begin", 0, 0, 0, 0, 0, 0, 0,
5307 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5308 "print",
5309 "execute",
5310 "insert",
5311 0, /* 0xff64 */
5312 "undo",
5313 "redo",
5314 "menu",
5315 "find",
5316 "cancel",
5317 "help",
5318 "break", /* 0xff6b */
5320 0, 0, 0, 0,
5321 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5322 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5323 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5324 0, 0, 0, 0, 0, 0, 0, 0,
5325 "kp-tab", /* 0xff89 */
5326 0, 0, 0,
5327 "kp-enter", /* 0xff8d */
5328 0, 0, 0,
5329 "kp-f1", /* 0xff91 */
5330 "kp-f2",
5331 "kp-f3",
5332 "kp-f4",
5333 "kp-home", /* 0xff95 */
5334 "kp-left",
5335 "kp-up",
5336 "kp-right",
5337 "kp-down",
5338 "kp-prior", /* kp-page-up */
5339 "kp-next", /* kp-page-down */
5340 "kp-end",
5341 "kp-begin",
5342 "kp-insert",
5343 "kp-delete",
5344 0, /* 0xffa0 */
5345 0, 0, 0, 0, 0, 0, 0, 0, 0,
5346 "kp-multiply", /* 0xffaa */
5347 "kp-add",
5348 "kp-separator",
5349 "kp-subtract",
5350 "kp-decimal",
5351 "kp-divide", /* 0xffaf */
5352 "kp-0", /* 0xffb0 */
5353 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5354 0, /* 0xffba */
5355 0, 0,
5356 "kp-equal", /* 0xffbd */
5357 "f1", /* 0xffbe */ /* IsFunctionKey */
5358 "f2",
5359 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5360 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5361 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5362 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5363 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5364 0, 0, 0, 0, 0, 0, 0, 0,
5365 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5366 0, 0, 0, 0, 0, 0, 0, "delete"
5369 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5370 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5372 static char *iso_lispy_function_keys[] =
5374 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5375 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5376 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5377 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5378 "iso-lefttab", /* 0xfe20 */
5379 "iso-move-line-up", "iso-move-line-down",
5380 "iso-partial-line-up", "iso-partial-line-down",
5381 "iso-partial-space-left", "iso-partial-space-right",
5382 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5383 "iso-release-margin-left", "iso-release-margin-right",
5384 "iso-release-both-margins",
5385 "iso-fast-cursor-left", "iso-fast-cursor-right",
5386 "iso-fast-cursor-up", "iso-fast-cursor-down",
5387 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5388 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5391 #endif /* not HAVE_NTGUI */
5393 Lisp_Object Vlispy_mouse_stem;
5395 static char *lispy_wheel_names[] =
5397 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5400 /* drag-n-drop events are generated when a set of selected files are
5401 dragged from another application and dropped onto an Emacs window. */
5402 static char *lispy_drag_n_drop_names[] =
5404 "drag-n-drop"
5407 /* Scroll bar parts. */
5408 Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
5409 Lisp_Object Qup, Qdown, Qbottom, Qend_scroll;
5410 Lisp_Object Qtop, Qratio;
5412 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5413 Lisp_Object *scroll_bar_parts[] = {
5414 &Qabove_handle, &Qhandle, &Qbelow_handle,
5415 &Qup, &Qdown, &Qtop, &Qbottom, &Qend_scroll, &Qratio
5418 /* A vector, indexed by button number, giving the down-going location
5419 of currently depressed buttons, both scroll bar and non-scroll bar.
5421 The elements have the form
5422 (BUTTON-NUMBER MODIFIER-MASK . REST)
5423 where REST is the cdr of a position as it would be reported in the event.
5425 The make_lispy_event function stores positions here to tell the
5426 difference between click and drag events, and to store the starting
5427 location to be included in drag events. */
5429 static Lisp_Object button_down_location;
5431 /* Information about the most recent up-going button event: Which
5432 button, what location, and what time. */
5434 static int last_mouse_button;
5435 static int last_mouse_x;
5436 static int last_mouse_y;
5437 static unsigned long button_down_time;
5439 /* The maximum time between clicks to make a double-click, or Qnil to
5440 disable double-click detection, or Qt for no time limit. */
5442 Lisp_Object Vdouble_click_time;
5444 /* Maximum number of pixels the mouse may be moved between clicks
5445 to make a double-click. */
5447 EMACS_INT double_click_fuzz;
5449 /* The number of clicks in this multiple-click. */
5451 int double_click_count;
5453 /* Return position of a mouse click or wheel event */
5455 static Lisp_Object
5456 make_lispy_position (f, x, y, time)
5457 struct frame *f;
5458 Lisp_Object *x, *y;
5459 unsigned long time;
5461 Lisp_Object window;
5462 enum window_part part;
5463 Lisp_Object posn = Qnil;
5464 Lisp_Object extra_info = Qnil;
5465 int wx, wy;
5467 /* Set `window' to the window under frame pixel coordinates (x,y) */
5468 if (f)
5469 window = window_from_coordinates (f, XINT (*x), XINT (*y),
5470 &part, &wx, &wy, 0);
5471 else
5472 window = Qnil;
5474 if (WINDOWP (window))
5476 /* It's a click in window window at frame coordinates (x,y) */
5477 struct window *w = XWINDOW (window);
5478 Lisp_Object string_info = Qnil;
5479 int textpos = -1, rx = -1, ry = -1;
5480 int dx = -1, dy = -1;
5481 int width = -1, height = -1;
5482 Lisp_Object object = Qnil;
5484 /* Set event coordinates to window-relative coordinates
5485 for constructing the Lisp event below. */
5486 XSETINT (*x, wx);
5487 XSETINT (*y, wy);
5489 if (part == ON_TEXT)
5491 wx += WINDOW_LEFT_MARGIN_WIDTH (w);
5493 else if (part == ON_MODE_LINE || part == ON_HEADER_LINE)
5495 /* Mode line or header line. Look for a string under
5496 the mouse that may have a `local-map' property. */
5497 Lisp_Object string;
5498 int charpos;
5500 posn = part == ON_MODE_LINE ? Qmode_line : Qheader_line;
5501 rx = wx, ry = wy;
5502 string = mode_line_string (w, part, &rx, &ry, &charpos,
5503 &object, &dx, &dy, &width, &height);
5504 if (STRINGP (string))
5505 string_info = Fcons (string, make_number (charpos));
5506 if (w == XWINDOW (selected_window)
5507 && current_buffer == XBUFFER (w->buffer))
5508 textpos = PT;
5509 else
5510 textpos = XMARKER (w->pointm)->charpos;
5512 else if (part == ON_VERTICAL_BORDER)
5514 posn = Qvertical_line;
5515 wx = -1;
5516 dx = 0;
5517 width = 1;
5519 else if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
5521 Lisp_Object string;
5522 int charpos;
5524 posn = (part == ON_LEFT_MARGIN) ? Qleft_margin : Qright_margin;
5525 rx = wx, ry = wy;
5526 string = marginal_area_string (w, part, &rx, &ry, &charpos,
5527 &object, &dx, &dy, &width, &height);
5528 if (STRINGP (string))
5529 string_info = Fcons (string, make_number (charpos));
5530 if (part == ON_LEFT_MARGIN)
5531 wx = 0;
5532 else
5533 wx = window_box_right_offset (w, TEXT_AREA) - 1;
5535 else if (part == ON_LEFT_FRINGE)
5537 posn = Qleft_fringe;
5538 rx = 0;
5539 dx = wx;
5540 wx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5542 : window_box_width (w, LEFT_MARGIN_AREA));
5543 dx -= wx;
5545 else if (part == ON_RIGHT_FRINGE)
5547 posn = Qright_fringe;
5548 rx = 0;
5549 dx = wx;
5550 wx = (window_box_width (w, LEFT_MARGIN_AREA)
5551 + window_box_width (w, TEXT_AREA)
5552 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
5553 ? window_box_width (w, RIGHT_MARGIN_AREA)
5554 : 0));
5555 dx -= wx;
5557 else
5559 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5560 wx = max (WINDOW_LEFT_MARGIN_WIDTH (w), wx);
5563 if (textpos < 0)
5565 Lisp_Object string2, object2 = Qnil;
5566 struct display_pos p;
5567 int dx2, dy2;
5568 int width2, height2;
5569 string2 = buffer_posn_from_coords (w, &wx, &wy, &p,
5570 &object2, &dx2, &dy2,
5571 &width2, &height2);
5572 textpos = CHARPOS (p.pos);
5573 if (rx < 0) rx = wx;
5574 if (ry < 0) ry = wy;
5575 if (dx < 0) dx = dx2;
5576 if (dy < 0) dy = dy2;
5577 if (width < 0) width = width2;
5578 if (height < 0) height = height2;
5580 if (NILP (posn))
5582 posn = make_number (textpos);
5583 if (STRINGP (string2))
5584 string_info = Fcons (string2,
5585 make_number (CHARPOS (p.string_pos)));
5587 if (NILP (object))
5588 object = object2;
5591 #ifdef HAVE_WINDOW_SYSTEM
5592 if (IMAGEP (object))
5594 Lisp_Object image_map, hotspot;
5595 if ((image_map = Fplist_get (XCDR (object), QCmap),
5596 !NILP (image_map))
5597 && (hotspot = find_hot_spot (image_map, dx, dy),
5598 CONSP (hotspot))
5599 && (hotspot = XCDR (hotspot), CONSP (hotspot)))
5600 posn = XCAR (hotspot);
5602 #endif
5604 /* Object info */
5605 extra_info = Fcons (object,
5606 Fcons (Fcons (make_number (dx),
5607 make_number (dy)),
5608 Fcons (Fcons (make_number (width),
5609 make_number (height)),
5610 Qnil)));
5612 /* String info */
5613 extra_info = Fcons (string_info,
5614 Fcons (make_number (textpos),
5615 Fcons (Fcons (make_number (rx),
5616 make_number (ry)),
5617 extra_info)));
5619 else if (f != 0)
5621 XSETFRAME (window, f);
5623 else
5625 window = Qnil;
5626 XSETFASTINT (*x, 0);
5627 XSETFASTINT (*y, 0);
5630 return Fcons (window,
5631 Fcons (posn,
5632 Fcons (Fcons (*x, *y),
5633 Fcons (make_number (time),
5634 extra_info))));
5637 /* Given a struct input_event, build the lisp event which represents
5638 it. If EVENT is 0, build a mouse movement event from the mouse
5639 movement buffer, which should have a movement event in it.
5641 Note that events must be passed to this function in the order they
5642 are received; this function stores the location of button presses
5643 in order to build drag events when the button is released. */
5645 static Lisp_Object
5646 make_lispy_event (event)
5647 struct input_event *event;
5649 int i;
5651 switch (SWITCH_ENUM_CAST (event->kind))
5653 /* A simple keystroke. */
5654 case ASCII_KEYSTROKE_EVENT:
5655 case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
5657 Lisp_Object lispy_c;
5658 int c = event->code;
5659 if (event->kind == ASCII_KEYSTROKE_EVENT)
5661 c &= 0377;
5662 eassert (c == event->code);
5663 /* Turn ASCII characters into control characters
5664 when proper. */
5665 if (event->modifiers & ctrl_modifier)
5667 c = make_ctrl_char (c);
5668 event->modifiers &= ~ctrl_modifier;
5672 /* Add in the other modifier bits. The shift key was taken care
5673 of by the X code. */
5674 c |= (event->modifiers
5675 & (meta_modifier | alt_modifier
5676 | hyper_modifier | super_modifier | ctrl_modifier));
5677 /* Distinguish Shift-SPC from SPC. */
5678 if ((event->code) == 040
5679 && event->modifiers & shift_modifier)
5680 c |= shift_modifier;
5681 button_down_time = 0;
5682 XSETFASTINT (lispy_c, c);
5683 return lispy_c;
5686 #ifdef HAVE_NS
5687 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5688 except that they are non-key events (last-nonmenu-event is nil). */
5689 case NS_NONKEY_EVENT:
5690 #endif
5692 /* A function key. The symbol may need to have modifier prefixes
5693 tacked onto it. */
5694 case NON_ASCII_KEYSTROKE_EVENT:
5695 button_down_time = 0;
5697 for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
5698 if (event->code == lispy_accent_codes[i])
5699 return modify_event_symbol (i,
5700 event->modifiers,
5701 Qfunction_key, Qnil,
5702 lispy_accent_keys, &accent_key_syms,
5703 (sizeof (lispy_accent_keys)
5704 / sizeof (lispy_accent_keys[0])));
5706 #if 0
5707 #ifdef XK_kana_A
5708 if (event->code >= 0x400 && event->code < 0x500)
5709 return modify_event_symbol (event->code - 0x400,
5710 event->modifiers & ~shift_modifier,
5711 Qfunction_key, Qnil,
5712 lispy_kana_keys, &func_key_syms,
5713 (sizeof (lispy_kana_keys)
5714 / sizeof (lispy_kana_keys[0])));
5715 #endif /* XK_kana_A */
5716 #endif /* 0 */
5718 #ifdef ISO_FUNCTION_KEY_OFFSET
5719 if (event->code < FUNCTION_KEY_OFFSET
5720 && event->code >= ISO_FUNCTION_KEY_OFFSET)
5721 return modify_event_symbol (event->code - ISO_FUNCTION_KEY_OFFSET,
5722 event->modifiers,
5723 Qfunction_key, Qnil,
5724 iso_lispy_function_keys, &func_key_syms,
5725 (sizeof (iso_lispy_function_keys)
5726 / sizeof (iso_lispy_function_keys[0])));
5727 #endif
5729 /* Handle system-specific or unknown keysyms. */
5730 if (event->code & (1 << 28)
5731 || event->code - FUNCTION_KEY_OFFSET < 0
5732 || (event->code - FUNCTION_KEY_OFFSET
5733 >= sizeof lispy_function_keys / sizeof *lispy_function_keys)
5734 || !lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
5736 /* We need to use an alist rather than a vector as the cache
5737 since we can't make a vector long enuf. */
5738 if (NILP (current_kboard->system_key_syms))
5739 current_kboard->system_key_syms = Fcons (Qnil, Qnil);
5740 return modify_event_symbol (event->code,
5741 event->modifiers,
5742 Qfunction_key,
5743 current_kboard->Vsystem_key_alist,
5744 0, &current_kboard->system_key_syms,
5745 (unsigned) -1);
5748 return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
5749 event->modifiers,
5750 Qfunction_key, Qnil,
5751 lispy_function_keys, &func_key_syms,
5752 (sizeof (lispy_function_keys)
5753 / sizeof (lispy_function_keys[0])));
5755 #ifdef WINDOWSNT
5756 case MULTIMEDIA_KEY_EVENT:
5757 if (event->code < (sizeof (lispy_multimedia_keys)
5758 / sizeof (lispy_multimedia_keys[0]))
5759 && event->code > 0 && lispy_multimedia_keys[event->code])
5761 return modify_event_symbol (event->code, event->modifiers,
5762 Qfunction_key, Qnil,
5763 lispy_multimedia_keys, &func_key_syms,
5764 (sizeof (lispy_multimedia_keys)
5765 / sizeof (lispy_multimedia_keys[0])));
5767 return Qnil;
5768 #endif
5770 #ifdef HAVE_MOUSE
5771 /* A mouse click. Figure out where it is, decide whether it's
5772 a press, click or drag, and build the appropriate structure. */
5773 case MOUSE_CLICK_EVENT:
5774 #ifndef USE_TOOLKIT_SCROLL_BARS
5775 case SCROLL_BAR_CLICK_EVENT:
5776 #endif
5778 int button = event->code;
5779 int is_double;
5780 Lisp_Object position;
5781 Lisp_Object *start_pos_ptr;
5782 Lisp_Object start_pos;
5784 position = Qnil;
5786 /* Build the position as appropriate for this mouse click. */
5787 if (event->kind == MOUSE_CLICK_EVENT)
5789 struct frame *f = XFRAME (event->frame_or_window);
5790 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5791 int row, column;
5792 #endif
5794 /* Ignore mouse events that were made on frame that
5795 have been deleted. */
5796 if (! FRAME_LIVE_P (f))
5797 return Qnil;
5799 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5800 /* EVENT->x and EVENT->y are frame-relative pixel
5801 coordinates at this place. Under old redisplay, COLUMN
5802 and ROW are set to frame relative glyph coordinates
5803 which are then used to determine whether this click is
5804 in a menu (non-toolkit version). */
5805 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
5806 &column, &row, NULL, 1);
5808 /* In the non-toolkit version, clicks on the menu bar
5809 are ordinary button events in the event buffer.
5810 Distinguish them, and invoke the menu.
5812 (In the toolkit version, the toolkit handles the menu bar
5813 and Emacs doesn't know about it until after the user
5814 makes a selection.) */
5815 if (row >= 0 && row < FRAME_MENU_BAR_LINES (f)
5816 && (event->modifiers & down_modifier))
5818 Lisp_Object items, item;
5819 int hpos;
5820 int i;
5822 #if 0
5823 /* Activate the menu bar on the down event. If the
5824 up event comes in before the menu code can deal with it,
5825 just ignore it. */
5826 if (! (event->modifiers & down_modifier))
5827 return Qnil;
5828 #endif
5830 /* Find the menu bar item under `column'. */
5831 item = Qnil;
5832 items = FRAME_MENU_BAR_ITEMS (f);
5833 for (i = 0; i < XVECTOR (items)->size; i += 4)
5835 Lisp_Object pos, string;
5836 string = AREF (items, i + 1);
5837 pos = AREF (items, i + 3);
5838 if (NILP (string))
5839 break;
5840 if (column >= XINT (pos)
5841 && column < XINT (pos) + SCHARS (string))
5843 item = AREF (items, i);
5844 break;
5848 /* ELisp manual 2.4b says (x y) are window relative but
5849 code says they are frame-relative. */
5850 position
5851 = Fcons (event->frame_or_window,
5852 Fcons (Qmenu_bar,
5853 Fcons (Fcons (event->x, event->y),
5854 Fcons (make_number (event->timestamp),
5855 Qnil))));
5857 return Fcons (item, Fcons (position, Qnil));
5859 #endif /* not USE_X_TOOLKIT && not USE_GTK && not HAVE_NS */
5861 position = make_lispy_position (f, &event->x, &event->y,
5862 event->timestamp);
5864 #ifndef USE_TOOLKIT_SCROLL_BARS
5865 else
5867 /* It's a scrollbar click. */
5868 Lisp_Object window;
5869 Lisp_Object portion_whole;
5870 Lisp_Object part;
5872 window = event->frame_or_window;
5873 portion_whole = Fcons (event->x, event->y);
5874 part = *scroll_bar_parts[(int) event->part];
5876 position
5877 = Fcons (window,
5878 Fcons (Qvertical_scroll_bar,
5879 Fcons (portion_whole,
5880 Fcons (make_number (event->timestamp),
5881 Fcons (part, Qnil)))));
5883 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5885 if (button >= ASIZE (button_down_location))
5887 button_down_location = larger_vector (button_down_location,
5888 button + 1, Qnil);
5889 mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
5892 start_pos_ptr = &AREF (button_down_location, button);
5893 start_pos = *start_pos_ptr;
5894 *start_pos_ptr = Qnil;
5897 /* On window-system frames, use the value of
5898 double-click-fuzz as is. On other frames, interpret it
5899 as a multiple of 1/8 characters. */
5900 struct frame *f;
5901 int fuzz;
5903 if (WINDOWP (event->frame_or_window))
5904 f = XFRAME (XWINDOW (event->frame_or_window)->frame);
5905 else if (FRAMEP (event->frame_or_window))
5906 f = XFRAME (event->frame_or_window);
5907 else
5908 abort ();
5910 if (FRAME_WINDOW_P (f))
5911 fuzz = double_click_fuzz;
5912 else
5913 fuzz = double_click_fuzz / 8;
5915 is_double = (button == last_mouse_button
5916 && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
5917 && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
5918 && button_down_time != 0
5919 && (EQ (Vdouble_click_time, Qt)
5920 || (INTEGERP (Vdouble_click_time)
5921 && ((int)(event->timestamp - button_down_time)
5922 < XINT (Vdouble_click_time)))));
5925 last_mouse_button = button;
5926 last_mouse_x = XINT (event->x);
5927 last_mouse_y = XINT (event->y);
5929 /* If this is a button press, squirrel away the location, so
5930 we can decide later whether it was a click or a drag. */
5931 if (event->modifiers & down_modifier)
5933 if (is_double)
5935 double_click_count++;
5936 event->modifiers |= ((double_click_count > 2)
5937 ? triple_modifier
5938 : double_modifier);
5940 else
5941 double_click_count = 1;
5942 button_down_time = event->timestamp;
5943 *start_pos_ptr = Fcopy_alist (position);
5944 ignore_mouse_drag_p = 0;
5947 /* Now we're releasing a button - check the co-ordinates to
5948 see if this was a click or a drag. */
5949 else if (event->modifiers & up_modifier)
5951 /* If we did not see a down before this up, ignore the up.
5952 Probably this happened because the down event chose a
5953 menu item. It would be an annoyance to treat the
5954 release of the button that chose the menu item as a
5955 separate event. */
5957 if (!CONSP (start_pos))
5958 return Qnil;
5960 event->modifiers &= ~up_modifier;
5961 #if 0 /* Formerly we treated an up with no down as a click event. */
5962 if (!CONSP (start_pos))
5963 event->modifiers |= click_modifier;
5964 else
5965 #endif
5967 Lisp_Object down;
5968 EMACS_INT xdiff = double_click_fuzz, ydiff = double_click_fuzz;
5970 /* The third element of every position
5971 should be the (x,y) pair. */
5972 down = Fcar (Fcdr (Fcdr (start_pos)));
5973 if (CONSP (down)
5974 && INTEGERP (XCAR (down)) && INTEGERP (XCDR (down)))
5976 xdiff = XINT (event->x) - XINT (XCAR (down));
5977 ydiff = XINT (event->y) - XINT (XCDR (down));
5980 if (ignore_mouse_drag_p)
5982 event->modifiers |= click_modifier;
5983 ignore_mouse_drag_p = 0;
5985 else if (xdiff < double_click_fuzz && xdiff > - double_click_fuzz
5986 && ydiff < double_click_fuzz && ydiff > - double_click_fuzz
5987 /* Maybe the mouse has moved a lot, caused scrolling, and
5988 eventually ended up at the same screen position (but
5989 not buffer position) in which case it is a drag, not
5990 a click. */
5991 /* FIXME: OTOH if the buffer position has changed
5992 because of a timer or process filter rather than
5993 because of mouse movement, it should be considered as
5994 a click. But mouse-drag-region completely ignores
5995 this case and it hasn't caused any real problem, so
5996 it's probably OK to ignore it as well. */
5997 && EQ (Fcar (Fcdr (start_pos)), Fcar (Fcdr (position))))
5998 /* Mouse hasn't moved (much). */
5999 event->modifiers |= click_modifier;
6000 else
6002 button_down_time = 0;
6003 event->modifiers |= drag_modifier;
6006 /* Don't check is_double; treat this as multiple
6007 if the down-event was multiple. */
6008 if (double_click_count > 1)
6009 event->modifiers |= ((double_click_count > 2)
6010 ? triple_modifier
6011 : double_modifier);
6014 else
6015 /* Every mouse event should either have the down_modifier or
6016 the up_modifier set. */
6017 abort ();
6020 /* Get the symbol we should use for the mouse click. */
6021 Lisp_Object head;
6023 head = modify_event_symbol (button,
6024 event->modifiers,
6025 Qmouse_click, Vlispy_mouse_stem,
6026 NULL,
6027 &mouse_syms,
6028 XVECTOR (mouse_syms)->size);
6029 if (event->modifiers & drag_modifier)
6030 return Fcons (head,
6031 Fcons (start_pos,
6032 Fcons (position,
6033 Qnil)));
6034 else if (event->modifiers & (double_modifier | triple_modifier))
6035 return Fcons (head,
6036 Fcons (position,
6037 Fcons (make_number (double_click_count),
6038 Qnil)));
6039 else
6040 return Fcons (head,
6041 Fcons (position,
6042 Qnil));
6046 case WHEEL_EVENT:
6047 case HORIZ_WHEEL_EVENT:
6049 Lisp_Object position;
6050 Lisp_Object head;
6052 /* Build the position as appropriate for this mouse click. */
6053 struct frame *f = XFRAME (event->frame_or_window);
6055 /* Ignore wheel events that were made on frame that have been
6056 deleted. */
6057 if (! FRAME_LIVE_P (f))
6058 return Qnil;
6060 position = make_lispy_position (f, &event->x, &event->y,
6061 event->timestamp);
6063 /* Set double or triple modifiers to indicate the wheel speed. */
6065 /* On window-system frames, use the value of
6066 double-click-fuzz as is. On other frames, interpret it
6067 as a multiple of 1/8 characters. */
6068 struct frame *f;
6069 int fuzz;
6070 int symbol_num;
6071 int is_double;
6073 if (WINDOWP (event->frame_or_window))
6074 f = XFRAME (XWINDOW (event->frame_or_window)->frame);
6075 else if (FRAMEP (event->frame_or_window))
6076 f = XFRAME (event->frame_or_window);
6077 else
6078 abort ();
6080 if (FRAME_WINDOW_P (f))
6081 fuzz = double_click_fuzz;
6082 else
6083 fuzz = double_click_fuzz / 8;
6085 if (event->modifiers & up_modifier)
6087 /* Emit a wheel-up event. */
6088 event->modifiers &= ~up_modifier;
6089 symbol_num = 0;
6091 else if (event->modifiers & down_modifier)
6093 /* Emit a wheel-down event. */
6094 event->modifiers &= ~down_modifier;
6095 symbol_num = 1;
6097 else
6098 /* Every wheel event should either have the down_modifier or
6099 the up_modifier set. */
6100 abort ();
6102 if (event->kind == HORIZ_WHEEL_EVENT)
6103 symbol_num += 2;
6105 is_double = (last_mouse_button == - (1 + symbol_num)
6106 && (eabs (XINT (event->x) - last_mouse_x) <= fuzz)
6107 && (eabs (XINT (event->y) - last_mouse_y) <= fuzz)
6108 && button_down_time != 0
6109 && (EQ (Vdouble_click_time, Qt)
6110 || (INTEGERP (Vdouble_click_time)
6111 && ((int)(event->timestamp - button_down_time)
6112 < XINT (Vdouble_click_time)))));
6113 if (is_double)
6115 double_click_count++;
6116 event->modifiers |= ((double_click_count > 2)
6117 ? triple_modifier
6118 : double_modifier);
6120 else
6122 double_click_count = 1;
6123 event->modifiers |= click_modifier;
6126 button_down_time = event->timestamp;
6127 /* Use a negative value to distinguish wheel from mouse button. */
6128 last_mouse_button = - (1 + symbol_num);
6129 last_mouse_x = XINT (event->x);
6130 last_mouse_y = XINT (event->y);
6132 /* Get the symbol we should use for the wheel event. */
6133 head = modify_event_symbol (symbol_num,
6134 event->modifiers,
6135 Qmouse_click,
6136 Qnil,
6137 lispy_wheel_names,
6138 &wheel_syms,
6139 ASIZE (wheel_syms));
6142 if (event->modifiers & (double_modifier | triple_modifier))
6143 return Fcons (head,
6144 Fcons (position,
6145 Fcons (make_number (double_click_count),
6146 Qnil)));
6147 else
6148 return Fcons (head,
6149 Fcons (position,
6150 Qnil));
6154 #ifdef USE_TOOLKIT_SCROLL_BARS
6156 /* We don't have down and up events if using toolkit scroll bars,
6157 so make this always a click event. Store in the `part' of
6158 the Lisp event a symbol which maps to the following actions:
6160 `above_handle' page up
6161 `below_handle' page down
6162 `up' line up
6163 `down' line down
6164 `top' top of buffer
6165 `bottom' bottom of buffer
6166 `handle' thumb has been dragged.
6167 `end-scroll' end of interaction with scroll bar
6169 The incoming input_event contains in its `part' member an
6170 index of type `enum scroll_bar_part' which we can use as an
6171 index in scroll_bar_parts to get the appropriate symbol. */
6173 case SCROLL_BAR_CLICK_EVENT:
6175 Lisp_Object position, head, window, portion_whole, part;
6177 window = event->frame_or_window;
6178 portion_whole = Fcons (event->x, event->y);
6179 part = *scroll_bar_parts[(int) event->part];
6181 position
6182 = Fcons (window,
6183 Fcons (Qvertical_scroll_bar,
6184 Fcons (portion_whole,
6185 Fcons (make_number (event->timestamp),
6186 Fcons (part, Qnil)))));
6188 /* Always treat scroll bar events as clicks. */
6189 event->modifiers |= click_modifier;
6190 event->modifiers &= ~up_modifier;
6192 if (event->code >= ASIZE (mouse_syms))
6193 mouse_syms = larger_vector (mouse_syms, event->code + 1, Qnil);
6195 /* Get the symbol we should use for the mouse click. */
6196 head = modify_event_symbol (event->code,
6197 event->modifiers,
6198 Qmouse_click,
6199 Vlispy_mouse_stem,
6200 NULL, &mouse_syms,
6201 XVECTOR (mouse_syms)->size);
6202 return Fcons (head, Fcons (position, Qnil));
6205 #endif /* USE_TOOLKIT_SCROLL_BARS */
6207 case DRAG_N_DROP_EVENT:
6209 FRAME_PTR f;
6210 Lisp_Object head, position;
6211 Lisp_Object files;
6213 f = XFRAME (event->frame_or_window);
6214 files = event->arg;
6216 /* Ignore mouse events that were made on frames that
6217 have been deleted. */
6218 if (! FRAME_LIVE_P (f))
6219 return Qnil;
6221 position = make_lispy_position (f, &event->x, &event->y,
6222 event->timestamp);
6224 head = modify_event_symbol (0, event->modifiers,
6225 Qdrag_n_drop, Qnil,
6226 lispy_drag_n_drop_names,
6227 &drag_n_drop_syms, 1);
6228 return Fcons (head,
6229 Fcons (position,
6230 Fcons (files,
6231 Qnil)));
6233 #endif /* HAVE_MOUSE */
6235 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
6236 || defined(HAVE_NS) || defined (USE_GTK)
6237 case MENU_BAR_EVENT:
6238 if (EQ (event->arg, event->frame_or_window))
6239 /* This is the prefix key. We translate this to
6240 `(menu_bar)' because the code in keyboard.c for menu
6241 events, which we use, relies on this. */
6242 return Fcons (Qmenu_bar, Qnil);
6243 return event->arg;
6244 #endif
6246 case SELECT_WINDOW_EVENT:
6247 /* Make an event (select-window (WINDOW)). */
6248 return Fcons (Qselect_window,
6249 Fcons (Fcons (event->frame_or_window, Qnil),
6250 Qnil));
6252 case TOOL_BAR_EVENT:
6253 if (EQ (event->arg, event->frame_or_window))
6254 /* This is the prefix key. We translate this to
6255 `(tool_bar)' because the code in keyboard.c for tool bar
6256 events, which we use, relies on this. */
6257 return Fcons (Qtool_bar, Qnil);
6258 else if (SYMBOLP (event->arg))
6259 return apply_modifiers (event->modifiers, event->arg);
6260 return event->arg;
6262 case USER_SIGNAL_EVENT:
6263 /* A user signal. */
6265 char *name = find_user_signal_name (event->code);
6266 if (!name)
6267 abort ();
6268 return intern (name);
6271 case SAVE_SESSION_EVENT:
6272 return Qsave_session;
6274 #ifdef HAVE_DBUS
6275 case DBUS_EVENT:
6277 return Fcons (Qdbus_event, event->arg);
6279 #endif /* HAVE_DBUS */
6281 case CONFIG_CHANGED_EVENT:
6282 return Fcons (Qconfig_changed_event,
6283 Fcons (event->arg,
6284 Fcons (event->frame_or_window, Qnil)));
6285 #ifdef HAVE_GPM
6286 case GPM_CLICK_EVENT:
6288 FRAME_PTR f = XFRAME (event->frame_or_window);
6289 Lisp_Object head, position;
6290 Lisp_Object *start_pos_ptr;
6291 Lisp_Object start_pos;
6292 int button = event->code;
6294 if (button >= ASIZE (button_down_location))
6296 button_down_location = larger_vector (button_down_location,
6297 button + 1, Qnil);
6298 mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
6301 start_pos_ptr = &AREF (button_down_location, button);
6302 start_pos = *start_pos_ptr;
6304 position = make_lispy_position (f, &event->x, &event->y,
6305 event->timestamp);
6307 if (event->modifiers & down_modifier)
6308 *start_pos_ptr = Fcopy_alist (position);
6309 else if (event->modifiers & (up_modifier | drag_modifier))
6311 if (!CONSP (start_pos))
6312 return Qnil;
6313 event->modifiers &= ~up_modifier;
6316 head = modify_event_symbol (button,
6317 event->modifiers,
6318 Qmouse_click, Vlispy_mouse_stem,
6319 NULL,
6320 &mouse_syms,
6321 XVECTOR (mouse_syms)->size);
6323 if (event->modifiers & drag_modifier)
6324 return Fcons (head,
6325 Fcons (start_pos,
6326 Fcons (position,
6327 Qnil)));
6328 else if (event->modifiers & double_modifier)
6329 return Fcons (head,
6330 Fcons (position,
6331 Fcons (make_number (2),
6332 Qnil)));
6333 else if (event->modifiers & triple_modifier)
6334 return Fcons (head,
6335 Fcons (position,
6336 Fcons (make_number (3),
6337 Qnil)));
6338 else
6339 return Fcons (head,
6340 Fcons (position,
6341 Qnil));
6343 #endif /* HAVE_GPM */
6345 /* The 'kind' field of the event is something we don't recognize. */
6346 default:
6347 abort ();
6351 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6353 static Lisp_Object
6354 make_lispy_movement (frame, bar_window, part, x, y, time)
6355 FRAME_PTR frame;
6356 Lisp_Object bar_window;
6357 enum scroll_bar_part part;
6358 Lisp_Object x, y;
6359 unsigned long time;
6361 /* Is it a scroll bar movement? */
6362 if (frame && ! NILP (bar_window))
6364 Lisp_Object part_sym;
6366 part_sym = *scroll_bar_parts[(int) part];
6367 return Fcons (Qscroll_bar_movement,
6368 (Fcons (Fcons (bar_window,
6369 Fcons (Qvertical_scroll_bar,
6370 Fcons (Fcons (x, y),
6371 Fcons (make_number (time),
6372 Fcons (part_sym,
6373 Qnil))))),
6374 Qnil)));
6377 /* Or is it an ordinary mouse movement? */
6378 else
6380 Lisp_Object position;
6382 position = make_lispy_position (frame, &x, &y, time);
6384 return Fcons (Qmouse_movement,
6385 Fcons (position,
6386 Qnil));
6390 #endif /* HAVE_MOUSE || HAVE GPM */
6392 /* Construct a switch frame event. */
6393 static Lisp_Object
6394 make_lispy_switch_frame (frame)
6395 Lisp_Object frame;
6397 return Fcons (Qswitch_frame, Fcons (frame, Qnil));
6400 /* Manipulating modifiers. */
6402 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6404 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6405 SYMBOL's name of the end of the modifiers; the string from this
6406 position is the unmodified symbol name.
6408 This doesn't use any caches. */
6410 static int
6411 parse_modifiers_uncached (symbol, modifier_end)
6412 Lisp_Object symbol;
6413 int *modifier_end;
6415 Lisp_Object name;
6416 int i;
6417 int modifiers;
6419 CHECK_SYMBOL (symbol);
6421 modifiers = 0;
6422 name = SYMBOL_NAME (symbol);
6424 for (i = 0; i+2 <= SBYTES (name); )
6426 int this_mod_end = 0;
6427 int this_mod = 0;
6429 /* See if the name continues with a modifier word.
6430 Check that the word appears, but don't check what follows it.
6431 Set this_mod and this_mod_end to record what we find. */
6433 switch (SREF (name, i))
6435 #define SINGLE_LETTER_MOD(BIT) \
6436 (this_mod_end = i + 1, this_mod = BIT)
6438 case 'A':
6439 SINGLE_LETTER_MOD (alt_modifier);
6440 break;
6442 case 'C':
6443 SINGLE_LETTER_MOD (ctrl_modifier);
6444 break;
6446 case 'H':
6447 SINGLE_LETTER_MOD (hyper_modifier);
6448 break;
6450 case 'M':
6451 SINGLE_LETTER_MOD (meta_modifier);
6452 break;
6454 case 'S':
6455 SINGLE_LETTER_MOD (shift_modifier);
6456 break;
6458 case 's':
6459 SINGLE_LETTER_MOD (super_modifier);
6460 break;
6462 #undef SINGLE_LETTER_MOD
6464 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6465 if (i + LEN + 1 <= SBYTES (name) \
6466 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6468 this_mod_end = i + LEN; \
6469 this_mod = BIT; \
6472 case 'd':
6473 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
6474 MULTI_LETTER_MOD (down_modifier, "down", 4);
6475 MULTI_LETTER_MOD (double_modifier, "double", 6);
6476 break;
6478 case 't':
6479 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
6480 break;
6481 #undef MULTI_LETTER_MOD
6485 /* If we found no modifier, stop looking for them. */
6486 if (this_mod_end == 0)
6487 break;
6489 /* Check there is a dash after the modifier, so that it
6490 really is a modifier. */
6491 if (this_mod_end >= SBYTES (name)
6492 || SREF (name, this_mod_end) != '-')
6493 break;
6495 /* This modifier is real; look for another. */
6496 modifiers |= this_mod;
6497 i = this_mod_end + 1;
6500 /* Should we include the `click' modifier? */
6501 if (! (modifiers & (down_modifier | drag_modifier
6502 | double_modifier | triple_modifier))
6503 && i + 7 == SBYTES (name)
6504 && strncmp (SDATA (name) + i, "mouse-", 6) == 0
6505 && ('0' <= SREF (name, i + 6) && SREF (name, i + 6) <= '9'))
6506 modifiers |= click_modifier;
6508 if (! (modifiers & (double_modifier | triple_modifier))
6509 && i + 6 < SBYTES (name)
6510 && strncmp (SDATA (name) + i, "wheel-", 6) == 0)
6511 modifiers |= click_modifier;
6513 if (modifier_end)
6514 *modifier_end = i;
6516 return modifiers;
6519 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6520 prepended to the string BASE[0..BASE_LEN-1].
6521 This doesn't use any caches. */
6522 static Lisp_Object
6523 apply_modifiers_uncached (modifiers, base, base_len, base_len_byte)
6524 int modifiers;
6525 char *base;
6526 int base_len, base_len_byte;
6528 /* Since BASE could contain nulls, we can't use intern here; we have
6529 to use Fintern, which expects a genuine Lisp_String, and keeps a
6530 reference to it. */
6531 char *new_mods
6532 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6533 int mod_len;
6536 char *p = new_mods;
6538 /* Only the event queue may use the `up' modifier; it should always
6539 be turned into a click or drag event before presented to lisp code. */
6540 if (modifiers & up_modifier)
6541 abort ();
6543 if (modifiers & alt_modifier) { *p++ = 'A'; *p++ = '-'; }
6544 if (modifiers & ctrl_modifier) { *p++ = 'C'; *p++ = '-'; }
6545 if (modifiers & hyper_modifier) { *p++ = 'H'; *p++ = '-'; }
6546 if (modifiers & meta_modifier) { *p++ = 'M'; *p++ = '-'; }
6547 if (modifiers & shift_modifier) { *p++ = 'S'; *p++ = '-'; }
6548 if (modifiers & super_modifier) { *p++ = 's'; *p++ = '-'; }
6549 if (modifiers & double_modifier) { strcpy (p, "double-"); p += 7; }
6550 if (modifiers & triple_modifier) { strcpy (p, "triple-"); p += 7; }
6551 if (modifiers & down_modifier) { strcpy (p, "down-"); p += 5; }
6552 if (modifiers & drag_modifier) { strcpy (p, "drag-"); p += 5; }
6553 /* The click modifier is denoted by the absence of other modifiers. */
6555 *p = '\0';
6557 mod_len = p - new_mods;
6561 Lisp_Object new_name;
6563 new_name = make_uninit_multibyte_string (mod_len + base_len,
6564 mod_len + base_len_byte);
6565 bcopy (new_mods, SDATA (new_name), mod_len);
6566 bcopy (base, SDATA (new_name) + mod_len, base_len_byte);
6568 return Fintern (new_name, Qnil);
6573 static const char *modifier_names[] =
6575 "up", "down", "drag", "click", "double", "triple", 0, 0,
6576 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6577 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6579 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6581 static Lisp_Object modifier_symbols;
6583 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6584 static Lisp_Object
6585 lispy_modifier_list (modifiers)
6586 int modifiers;
6588 Lisp_Object modifier_list;
6589 int i;
6591 modifier_list = Qnil;
6592 for (i = 0; (1<<i) <= modifiers && i < NUM_MOD_NAMES; i++)
6593 if (modifiers & (1<<i))
6594 modifier_list = Fcons (XVECTOR (modifier_symbols)->contents[i],
6595 modifier_list);
6597 return modifier_list;
6601 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6602 where UNMODIFIED is the unmodified form of SYMBOL,
6603 MASK is the set of modifiers present in SYMBOL's name.
6604 This is similar to parse_modifiers_uncached, but uses the cache in
6605 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6606 Qevent_symbol_elements property. */
6608 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6610 Lisp_Object
6611 parse_modifiers (symbol)
6612 Lisp_Object symbol;
6614 Lisp_Object elements;
6616 if (INTEGERP (symbol))
6617 return (Fcons (make_number (KEY_TO_CHAR (symbol)),
6618 Fcons (make_number (XINT (symbol) & CHAR_MODIFIER_MASK),
6619 Qnil)));
6620 else if (!SYMBOLP (symbol))
6621 return Qnil;
6623 elements = Fget (symbol, Qevent_symbol_element_mask);
6624 if (CONSP (elements))
6625 return elements;
6626 else
6628 int end;
6629 int modifiers = parse_modifiers_uncached (symbol, &end);
6630 Lisp_Object unmodified;
6631 Lisp_Object mask;
6633 unmodified = Fintern (make_string (SDATA (SYMBOL_NAME (symbol)) + end,
6634 SBYTES (SYMBOL_NAME (symbol)) - end),
6635 Qnil);
6637 if (modifiers & ~INTMASK)
6638 abort ();
6639 XSETFASTINT (mask, modifiers);
6640 elements = Fcons (unmodified, Fcons (mask, Qnil));
6642 /* Cache the parsing results on SYMBOL. */
6643 Fput (symbol, Qevent_symbol_element_mask,
6644 elements);
6645 Fput (symbol, Qevent_symbol_elements,
6646 Fcons (unmodified, lispy_modifier_list (modifiers)));
6648 /* Since we know that SYMBOL is modifiers applied to unmodified,
6649 it would be nice to put that in unmodified's cache.
6650 But we can't, since we're not sure that parse_modifiers is
6651 canonical. */
6653 return elements;
6657 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers,
6658 Sevent_symbol_parse_modifiers, 1, 1, 0,
6659 doc: /* Parse the event symbol. For internal use. */)
6660 (symbol)
6661 Lisp_Object symbol;
6663 /* Fill the cache if needed. */
6664 parse_modifiers (symbol);
6665 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6666 and use the Lispier representation stored on Qevent_symbol_elements
6667 instead. */
6668 return Fget (symbol, Qevent_symbol_elements);
6671 /* Apply the modifiers MODIFIERS to the symbol BASE.
6672 BASE must be unmodified.
6674 This is like apply_modifiers_uncached, but uses BASE's
6675 Qmodifier_cache property, if present. It also builds
6676 Qevent_symbol_elements properties, since it has that info anyway.
6678 apply_modifiers copies the value of BASE's Qevent_kind property to
6679 the modified symbol. */
6680 static Lisp_Object
6681 apply_modifiers (modifiers, base)
6682 int modifiers;
6683 Lisp_Object base;
6685 Lisp_Object cache, index, entry, new_symbol;
6687 /* Mask out upper bits. We don't know where this value's been. */
6688 modifiers &= INTMASK;
6690 if (INTEGERP (base))
6691 return make_number (XINT (base) | modifiers);
6693 /* The click modifier never figures into cache indices. */
6694 cache = Fget (base, Qmodifier_cache);
6695 XSETFASTINT (index, (modifiers & ~click_modifier));
6696 entry = assq_no_quit (index, cache);
6698 if (CONSP (entry))
6699 new_symbol = XCDR (entry);
6700 else
6702 /* We have to create the symbol ourselves. */
6703 new_symbol = apply_modifiers_uncached (modifiers,
6704 SDATA (SYMBOL_NAME (base)),
6705 SCHARS (SYMBOL_NAME (base)),
6706 SBYTES (SYMBOL_NAME (base)));
6708 /* Add the new symbol to the base's cache. */
6709 entry = Fcons (index, new_symbol);
6710 Fput (base, Qmodifier_cache, Fcons (entry, cache));
6712 /* We have the parsing info now for free, so we could add it to
6713 the caches:
6714 XSETFASTINT (index, modifiers);
6715 Fput (new_symbol, Qevent_symbol_element_mask,
6716 Fcons (base, Fcons (index, Qnil)));
6717 Fput (new_symbol, Qevent_symbol_elements,
6718 Fcons (base, lispy_modifier_list (modifiers)));
6719 Sadly, this is only correct if `base' is indeed a base event,
6720 which is not necessarily the case. -stef */
6723 /* Make sure this symbol is of the same kind as BASE.
6725 You'd think we could just set this once and for all when we
6726 intern the symbol above, but reorder_modifiers may call us when
6727 BASE's property isn't set right; we can't assume that just
6728 because it has a Qmodifier_cache property it must have its
6729 Qevent_kind set right as well. */
6730 if (NILP (Fget (new_symbol, Qevent_kind)))
6732 Lisp_Object kind;
6734 kind = Fget (base, Qevent_kind);
6735 if (! NILP (kind))
6736 Fput (new_symbol, Qevent_kind, kind);
6739 return new_symbol;
6743 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6744 return a symbol with the modifiers placed in the canonical order.
6745 Canonical order is alphabetical, except for down and drag, which
6746 always come last. The 'click' modifier is never written out.
6748 Fdefine_key calls this to make sure that (for example) C-M-foo
6749 and M-C-foo end up being equivalent in the keymap. */
6751 Lisp_Object
6752 reorder_modifiers (symbol)
6753 Lisp_Object symbol;
6755 /* It's hopefully okay to write the code this way, since everything
6756 will soon be in caches, and no consing will be done at all. */
6757 Lisp_Object parsed;
6759 parsed = parse_modifiers (symbol);
6760 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed))),
6761 XCAR (parsed));
6765 /* For handling events, we often want to produce a symbol whose name
6766 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6767 to some base, like the name of a function key or mouse button.
6768 modify_event_symbol produces symbols of this sort.
6770 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6771 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6772 in the table.
6774 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6775 into symbol names, or a string specifying a name stem used to
6776 construct a symbol name or the form `STEM-N', where N is the decimal
6777 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6778 non-nil; otherwise NAME_TABLE is used.
6780 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6781 persist between calls to modify_event_symbol that it can use to
6782 store a cache of the symbols it's generated for this NAME_TABLE
6783 before. The object stored there may be a vector or an alist.
6785 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6787 MODIFIERS is a set of modifier bits (as given in struct input_events)
6788 whose prefixes should be applied to the symbol name.
6790 SYMBOL_KIND is the value to be placed in the event_kind property of
6791 the returned symbol.
6793 The symbols we create are supposed to have an
6794 `event-symbol-elements' property, which lists the modifiers present
6795 in the symbol's name. */
6797 static Lisp_Object
6798 modify_event_symbol (symbol_num, modifiers, symbol_kind, name_alist_or_stem,
6799 name_table, symbol_table, table_size)
6800 int symbol_num;
6801 unsigned modifiers;
6802 Lisp_Object symbol_kind;
6803 Lisp_Object name_alist_or_stem;
6804 char **name_table;
6805 Lisp_Object *symbol_table;
6806 unsigned int table_size;
6808 Lisp_Object value;
6809 Lisp_Object symbol_int;
6811 /* Get rid of the "vendor-specific" bit here. */
6812 XSETINT (symbol_int, symbol_num & 0xffffff);
6814 /* Is this a request for a valid symbol? */
6815 if (symbol_num < 0 || symbol_num >= table_size)
6816 return Qnil;
6818 if (CONSP (*symbol_table))
6819 value = Fcdr (assq_no_quit (symbol_int, *symbol_table));
6821 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6822 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6823 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6824 we've never used that symbol before. */
6825 else
6827 if (! VECTORP (*symbol_table)
6828 || XVECTOR (*symbol_table)->size != table_size)
6830 Lisp_Object size;
6832 XSETFASTINT (size, table_size);
6833 *symbol_table = Fmake_vector (size, Qnil);
6836 value = XVECTOR (*symbol_table)->contents[symbol_num];
6839 /* Have we already used this symbol before? */
6840 if (NILP (value))
6842 /* No; let's create it. */
6843 if (CONSP (name_alist_or_stem))
6844 value = Fcdr_safe (Fassq (symbol_int, name_alist_or_stem));
6845 else if (STRINGP (name_alist_or_stem))
6847 int len = SBYTES (name_alist_or_stem);
6848 char *buf = (char *) alloca (len + 50);
6849 sprintf (buf, "%s-%ld", SDATA (name_alist_or_stem),
6850 (long) XINT (symbol_int) + 1);
6851 value = intern (buf);
6853 else if (name_table != 0 && name_table[symbol_num])
6854 value = intern (name_table[symbol_num]);
6856 #ifdef HAVE_WINDOW_SYSTEM
6857 if (NILP (value))
6859 char *name = x_get_keysym_name (symbol_num);
6860 if (name)
6861 value = intern (name);
6863 #endif
6865 if (NILP (value))
6867 char buf[20];
6868 sprintf (buf, "key-%d", symbol_num);
6869 value = intern (buf);
6872 if (CONSP (*symbol_table))
6873 *symbol_table = Fcons (Fcons (symbol_int, value), *symbol_table);
6874 else
6875 XVECTOR (*symbol_table)->contents[symbol_num] = value;
6877 /* Fill in the cache entries for this symbol; this also
6878 builds the Qevent_symbol_elements property, which the user
6879 cares about. */
6880 apply_modifiers (modifiers & click_modifier, value);
6881 Fput (value, Qevent_kind, symbol_kind);
6884 /* Apply modifiers to that symbol. */
6885 return apply_modifiers (modifiers, value);
6888 /* Convert a list that represents an event type,
6889 such as (ctrl meta backspace), into the usual representation of that
6890 event type as a number or a symbol. */
6892 DEFUN ("event-convert-list", Fevent_convert_list, Sevent_convert_list, 1, 1, 0,
6893 doc: /* Convert the event description list EVENT-DESC to an event type.
6894 EVENT-DESC should contain one base event type (a character or symbol)
6895 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6896 drag, down, double or triple). The base must be last.
6897 The return value is an event type (a character or symbol) which
6898 has the same base event type and all the specified modifiers. */)
6899 (event_desc)
6900 Lisp_Object event_desc;
6902 Lisp_Object base;
6903 int modifiers = 0;
6904 Lisp_Object rest;
6906 base = Qnil;
6907 rest = event_desc;
6908 while (CONSP (rest))
6910 Lisp_Object elt;
6911 int this = 0;
6913 elt = XCAR (rest);
6914 rest = XCDR (rest);
6916 /* Given a symbol, see if it is a modifier name. */
6917 if (SYMBOLP (elt) && CONSP (rest))
6918 this = parse_solitary_modifier (elt);
6920 if (this != 0)
6921 modifiers |= this;
6922 else if (!NILP (base))
6923 error ("Two bases given in one event");
6924 else
6925 base = elt;
6929 /* Let the symbol A refer to the character A. */
6930 if (SYMBOLP (base) && SCHARS (SYMBOL_NAME (base)) == 1)
6931 XSETINT (base, SREF (SYMBOL_NAME (base), 0));
6933 if (INTEGERP (base))
6935 /* Turn (shift a) into A. */
6936 if ((modifiers & shift_modifier) != 0
6937 && (XINT (base) >= 'a' && XINT (base) <= 'z'))
6939 XSETINT (base, XINT (base) - ('a' - 'A'));
6940 modifiers &= ~shift_modifier;
6943 /* Turn (control a) into C-a. */
6944 if (modifiers & ctrl_modifier)
6945 return make_number ((modifiers & ~ctrl_modifier)
6946 | make_ctrl_char (XINT (base)));
6947 else
6948 return make_number (modifiers | XINT (base));
6950 else if (SYMBOLP (base))
6951 return apply_modifiers (modifiers, base);
6952 else
6954 error ("Invalid base event");
6955 return Qnil;
6959 /* Try to recognize SYMBOL as a modifier name.
6960 Return the modifier flag bit, or 0 if not recognized. */
6963 parse_solitary_modifier (Lisp_Object symbol)
6965 Lisp_Object name = SYMBOL_NAME (symbol);
6967 switch (SREF (name, 0))
6969 #define SINGLE_LETTER_MOD(BIT) \
6970 if (SBYTES (name) == 1) \
6971 return BIT;
6973 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6974 if (LEN == SBYTES (name) \
6975 && ! strncmp (SDATA (name), NAME, LEN)) \
6976 return BIT;
6978 case 'A':
6979 SINGLE_LETTER_MOD (alt_modifier);
6980 break;
6982 case 'a':
6983 MULTI_LETTER_MOD (alt_modifier, "alt", 3);
6984 break;
6986 case 'C':
6987 SINGLE_LETTER_MOD (ctrl_modifier);
6988 break;
6990 case 'c':
6991 MULTI_LETTER_MOD (ctrl_modifier, "ctrl", 4);
6992 MULTI_LETTER_MOD (ctrl_modifier, "control", 7);
6993 break;
6995 case 'H':
6996 SINGLE_LETTER_MOD (hyper_modifier);
6997 break;
6999 case 'h':
7000 MULTI_LETTER_MOD (hyper_modifier, "hyper", 5);
7001 break;
7003 case 'M':
7004 SINGLE_LETTER_MOD (meta_modifier);
7005 break;
7007 case 'm':
7008 MULTI_LETTER_MOD (meta_modifier, "meta", 4);
7009 break;
7011 case 'S':
7012 SINGLE_LETTER_MOD (shift_modifier);
7013 break;
7015 case 's':
7016 MULTI_LETTER_MOD (shift_modifier, "shift", 5);
7017 MULTI_LETTER_MOD (super_modifier, "super", 5);
7018 SINGLE_LETTER_MOD (super_modifier);
7019 break;
7021 case 'd':
7022 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
7023 MULTI_LETTER_MOD (down_modifier, "down", 4);
7024 MULTI_LETTER_MOD (double_modifier, "double", 6);
7025 break;
7027 case 't':
7028 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
7029 break;
7031 #undef SINGLE_LETTER_MOD
7032 #undef MULTI_LETTER_MOD
7035 return 0;
7038 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
7039 Such a list is not valid as an event,
7040 but it can be a Lucid-style event type list. */
7043 lucid_event_type_list_p (object)
7044 Lisp_Object object;
7046 Lisp_Object tail;
7048 if (! CONSP (object))
7049 return 0;
7051 if (EQ (XCAR (object), Qhelp_echo)
7052 || EQ (XCAR (object), Qvertical_line)
7053 || EQ (XCAR (object), Qmode_line)
7054 || EQ (XCAR (object), Qheader_line))
7055 return 0;
7057 for (tail = object; CONSP (tail); tail = XCDR (tail))
7059 Lisp_Object elt;
7060 elt = XCAR (tail);
7061 if (! (INTEGERP (elt) || SYMBOLP (elt)))
7062 return 0;
7065 return NILP (tail);
7068 /* Store into *addr a value nonzero if terminal input chars are available.
7069 Serves the purpose of ioctl (0, FIONREAD, addr)
7070 but works even if FIONREAD does not exist.
7071 (In fact, this may actually read some input.)
7073 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
7074 timer events that are ripe.
7075 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
7076 events (FOCUS_IN_EVENT).
7077 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
7078 movements and toolkit scroll bar thumb drags. */
7080 static void
7081 get_input_pending (addr, flags)
7082 int *addr;
7083 int flags;
7085 /* First of all, have we already counted some input? */
7086 *addr = (!NILP (Vquit_flag) || readable_events (flags));
7088 /* If input is being read as it arrives, and we have none, there is none. */
7089 if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
7090 return;
7092 /* Try to read some input and see how much we get. */
7093 gobble_input (0);
7094 *addr = (!NILP (Vquit_flag) || readable_events (flags));
7097 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
7099 void
7100 gobble_input (expected)
7101 int expected;
7103 #ifdef SIGIO
7104 if (interrupt_input)
7106 SIGMASKTYPE mask;
7107 mask = sigblock (sigmask (SIGIO));
7108 read_avail_input (expected);
7109 sigsetmask (mask);
7111 else
7112 #ifdef POLL_FOR_INPUT
7113 /* XXX This condition was (read_socket_hook && !interrupt_input),
7114 but read_socket_hook is not global anymore. Let's pretend that
7115 it's always set. */
7116 if (!interrupt_input && poll_suppress_count == 0)
7118 SIGMASKTYPE mask;
7119 mask = sigblock (sigmask (SIGALRM));
7120 read_avail_input (expected);
7121 sigsetmask (mask);
7123 else
7124 #endif
7125 #endif
7126 read_avail_input (expected);
7129 /* Put a BUFFER_SWITCH_EVENT in the buffer
7130 so that read_key_sequence will notice the new current buffer. */
7132 void
7133 record_asynch_buffer_change ()
7135 struct input_event event;
7136 Lisp_Object tem;
7137 EVENT_INIT (event);
7139 event.kind = BUFFER_SWITCH_EVENT;
7140 event.frame_or_window = Qnil;
7141 event.arg = Qnil;
7143 #ifdef subprocesses
7144 /* We don't need a buffer-switch event unless Emacs is waiting for input.
7145 The purpose of the event is to make read_key_sequence look up the
7146 keymaps again. If we aren't in read_key_sequence, we don't need one,
7147 and the event could cause trouble by messing up (input-pending-p). */
7148 tem = Fwaiting_for_user_input_p ();
7149 if (NILP (tem))
7150 return;
7151 #else
7152 /* We never need these events if we have no asynchronous subprocesses. */
7153 return;
7154 #endif
7156 /* Make sure no interrupt happens while storing the event. */
7157 #ifdef SIGIO
7158 if (interrupt_input)
7160 SIGMASKTYPE mask;
7161 mask = sigblock (sigmask (SIGIO));
7162 kbd_buffer_store_event (&event);
7163 sigsetmask (mask);
7165 else
7166 #endif
7168 stop_polling ();
7169 kbd_buffer_store_event (&event);
7170 start_polling ();
7174 /* Read any terminal input already buffered up by the system
7175 into the kbd_buffer, but do not wait.
7177 EXPECTED should be nonzero if the caller knows there is some input.
7179 Returns the number of keyboard chars read, or -1 meaning
7180 this is a bad time to try to read input. */
7182 static int
7183 read_avail_input (expected)
7184 int expected;
7186 int nread = 0;
7187 int err = 0;
7188 struct terminal *t;
7190 /* Store pending user signal events, if any. */
7191 if (store_user_signal_events ())
7192 expected = 0;
7194 /* Loop through the available terminals, and call their input hooks. */
7195 t = terminal_list;
7196 while (t)
7198 struct terminal *next = t->next_terminal;
7200 if (t->read_socket_hook)
7202 int nr;
7203 struct input_event hold_quit;
7205 EVENT_INIT (hold_quit);
7206 hold_quit.kind = NO_EVENT;
7208 /* No need for FIONREAD or fcntl; just say don't wait. */
7209 while (nr = (*t->read_socket_hook) (t, expected, &hold_quit), nr > 0)
7211 nread += nr;
7212 expected = 0;
7215 if (nr == -1) /* Not OK to read input now. */
7217 err = 1;
7219 else if (nr == -2) /* Non-transient error. */
7221 /* The terminal device terminated; it should be closed. */
7223 /* Kill Emacs if this was our last terminal. */
7224 if (!terminal_list->next_terminal)
7225 /* Formerly simply reported no input, but that
7226 sometimes led to a failure of Emacs to terminate.
7227 SIGHUP seems appropriate if we can't reach the
7228 terminal. */
7229 /* ??? Is it really right to send the signal just to
7230 this process rather than to the whole process
7231 group? Perhaps on systems with FIONREAD Emacs is
7232 alone in its group. */
7233 kill (getpid (), SIGHUP);
7235 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
7237 Lisp_Object tmp;
7238 XSETTERMINAL (tmp, t);
7239 Fdelete_terminal (tmp, Qnoelisp);
7243 if (hold_quit.kind != NO_EVENT)
7244 kbd_buffer_store_event (&hold_quit);
7247 t = next;
7250 if (err && !nread)
7251 nread = -1;
7253 frame_make_pointer_visible ();
7255 return nread;
7258 static void
7259 decode_keyboard_code (struct tty_display_info *tty,
7260 struct coding_system *coding,
7261 unsigned char *buf, int nbytes)
7263 unsigned char *src = buf;
7264 const unsigned char *p;
7265 int i;
7267 if (nbytes == 0)
7268 return;
7269 if (tty->meta_key != 2)
7270 for (i = 0; i < nbytes; i++)
7271 buf[i] &= ~0x80;
7272 if (coding->carryover_bytes > 0)
7274 src = alloca (coding->carryover_bytes + nbytes);
7275 memcpy (src, coding->carryover, coding->carryover_bytes);
7276 memcpy (src + coding->carryover_bytes, buf, nbytes);
7277 nbytes += coding->carryover_bytes;
7279 coding->destination = alloca (nbytes * 4);
7280 coding->dst_bytes = nbytes * 4;
7281 decode_coding_c_string (coding, src, nbytes, Qnil);
7282 if (coding->produced_char == 0)
7283 return;
7284 for (i = 0, p = coding->destination; i < coding->produced_char; i++)
7286 struct input_event buf;
7288 EVENT_INIT (buf);
7289 buf.code = STRING_CHAR_ADVANCE (p);
7290 buf.kind = (ASCII_CHAR_P (buf.code)
7291 ? ASCII_KEYSTROKE_EVENT : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
7292 /* See the comment in tty_read_avail_input. */
7293 buf.frame_or_window = tty->top_frame;
7294 buf.arg = Qnil;
7295 kbd_buffer_store_event (&buf);
7299 /* This is the tty way of reading available input.
7301 Note that each terminal device has its own `struct terminal' object,
7302 and so this function is called once for each individual termcap
7303 terminal. The first parameter indicates which terminal to read from. */
7306 tty_read_avail_input (struct terminal *terminal,
7307 int expected,
7308 struct input_event *hold_quit)
7310 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
7311 the kbd_buffer can really hold. That may prevent loss
7312 of characters on some systems when input is stuffed at us. */
7313 unsigned char cbuf[KBD_BUFFER_SIZE - 1];
7314 int n_to_read, i;
7315 struct tty_display_info *tty = terminal->display_info.tty;
7316 int nread = 0;
7317 #ifdef subprocesses
7318 int buffer_free = KBD_BUFFER_SIZE - kbd_buffer_nr_stored () - 1;
7320 if (kbd_on_hold_p () || buffer_free <= 0)
7321 return 0;
7322 #endif /* subprocesses */
7324 if (!terminal->name) /* Don't read from a dead terminal. */
7325 return 0;
7327 if (terminal->type != output_termcap
7328 && terminal->type != output_msdos_raw)
7329 abort ();
7331 /* XXX I think the following code should be moved to separate hook
7332 functions in system-dependent files. */
7333 #ifdef WINDOWSNT
7334 return 0;
7335 #else /* not WINDOWSNT */
7336 if (! tty->term_initted) /* In case we get called during bootstrap. */
7337 return 0;
7339 if (! tty->input)
7340 return 0; /* The terminal is suspended. */
7342 #ifdef MSDOS
7343 n_to_read = dos_keysns ();
7344 if (n_to_read == 0)
7345 return 0;
7347 cbuf[0] = dos_keyread ();
7348 nread = 1;
7350 #else /* not MSDOS */
7351 #ifdef HAVE_GPM
7352 if (gpm_tty == tty)
7354 Gpm_Event event;
7355 struct input_event hold_quit;
7356 int gpm, fd = gpm_fd;
7358 EVENT_INIT (hold_quit);
7359 hold_quit.kind = NO_EVENT;
7361 /* gpm==1 if event received.
7362 gpm==0 if the GPM daemon has closed the connection, in which case
7363 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
7364 we save it in `fd' so close_gpm can remove it from the
7365 select masks.
7366 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
7367 while (gpm = Gpm_GetEvent (&event), gpm == 1) {
7368 nread += handle_one_term_event (tty, &event, &hold_quit);
7370 if (gpm == 0)
7371 /* Presumably the GPM daemon has closed the connection. */
7372 close_gpm (fd);
7373 if (hold_quit.kind != NO_EVENT)
7374 kbd_buffer_store_event (&hold_quit);
7375 if (nread)
7376 return nread;
7378 #endif /* HAVE_GPM */
7380 /* Determine how many characters we should *try* to read. */
7381 #ifdef FIONREAD
7382 /* Find out how much input is available. */
7383 if (ioctl (fileno (tty->input), FIONREAD, &n_to_read) < 0)
7385 if (! noninteractive)
7386 return -2; /* Close this terminal. */
7387 else
7388 n_to_read = 0;
7390 if (n_to_read == 0)
7391 return 0;
7392 if (n_to_read > sizeof cbuf)
7393 n_to_read = sizeof cbuf;
7394 #else /* no FIONREAD */
7395 #if defined (USG) || defined(CYGWIN)
7396 /* Read some input if available, but don't wait. */
7397 n_to_read = sizeof cbuf;
7398 fcntl (fileno (tty->input), F_SETFL, O_NDELAY);
7399 #else
7400 you lose;
7401 #endif
7402 #endif
7404 #ifdef subprocesses
7405 /* Don't read more than we can store. */
7406 if (n_to_read > buffer_free)
7407 n_to_read = buffer_free;
7408 #endif /* subprocesses */
7410 /* Now read; for one reason or another, this will not block.
7411 NREAD is set to the number of chars read. */
7414 nread = emacs_read (fileno (tty->input), cbuf, n_to_read);
7415 /* POSIX infers that processes which are not in the session leader's
7416 process group won't get SIGHUP's at logout time. BSDI adheres to
7417 this part standard and returns -1 from read (0) with errno==EIO
7418 when the control tty is taken away.
7419 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7420 if (nread == -1 && errno == EIO)
7421 return -2; /* Close this terminal. */
7422 #if defined (AIX) && defined (_BSD)
7423 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7424 This looks incorrect, but it isn't, because _BSD causes
7425 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7426 and that causes a value other than 0 when there is no input. */
7427 if (nread == 0)
7428 return -2; /* Close this terminal. */
7429 #endif
7431 while (
7432 /* We used to retry the read if it was interrupted.
7433 But this does the wrong thing when O_NDELAY causes
7434 an EAGAIN error. Does anybody know of a situation
7435 where a retry is actually needed? */
7436 #if 0
7437 nread < 0 && (errno == EAGAIN
7438 #ifdef EFAULT
7439 || errno == EFAULT
7440 #endif
7441 #ifdef EBADSLT
7442 || errno == EBADSLT
7443 #endif
7445 #else
7447 #endif
7450 #ifndef FIONREAD
7451 #if defined (USG) || defined (CYGWIN)
7452 fcntl (fileno (tty->input), F_SETFL, 0);
7453 #endif /* USG or CYGWIN */
7454 #endif /* no FIONREAD */
7456 if (nread <= 0)
7457 return nread;
7459 #endif /* not MSDOS */
7460 #endif /* not WINDOWSNT */
7462 if (TERMINAL_KEYBOARD_CODING (terminal)->common_flags
7463 & CODING_REQUIRE_DECODING_MASK)
7465 struct coding_system *coding = TERMINAL_KEYBOARD_CODING (terminal);
7466 int from;
7468 /* Decode the key sequence except for those with meta
7469 modifiers. */
7470 for (i = from = 0; ; i++)
7471 if (i == nread || (tty->meta_key == 1 && (cbuf[i] & 0x80)))
7473 struct input_event buf;
7475 decode_keyboard_code (tty, coding, cbuf + from, i - from);
7476 if (i == nread)
7477 break;
7479 EVENT_INIT (buf);
7480 buf.kind = ASCII_KEYSTROKE_EVENT;
7481 buf.modifiers = meta_modifier;
7482 buf.code = cbuf[i] & ~0x80;
7483 /* See the comment below. */
7484 buf.frame_or_window = tty->top_frame;
7485 buf.arg = Qnil;
7486 kbd_buffer_store_event (&buf);
7487 from = i + 1;
7489 return nread;
7492 for (i = 0; i < nread; i++)
7494 struct input_event buf;
7495 EVENT_INIT (buf);
7496 buf.kind = ASCII_KEYSTROKE_EVENT;
7497 buf.modifiers = 0;
7498 if (tty->meta_key == 1 && (cbuf[i] & 0x80))
7499 buf.modifiers = meta_modifier;
7500 if (tty->meta_key != 2)
7501 cbuf[i] &= ~0x80;
7503 buf.code = cbuf[i];
7504 /* Set the frame corresponding to the active tty. Note that the
7505 value of selected_frame is not reliable here, redisplay tends
7506 to temporarily change it. */
7507 buf.frame_or_window = tty->top_frame;
7508 buf.arg = Qnil;
7510 kbd_buffer_store_event (&buf);
7511 /* Don't look at input that follows a C-g too closely.
7512 This reduces lossage due to autorepeat on C-g. */
7513 if (buf.kind == ASCII_KEYSTROKE_EVENT
7514 && buf.code == quit_char)
7515 break;
7518 return nread;
7521 void
7522 handle_async_input ()
7524 interrupt_input_pending = 0;
7525 #ifdef SYNC_INPUT
7526 pending_signals = pending_atimers;
7527 #endif
7528 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
7529 doing anything dangerous. */
7530 #ifdef HAVE_NS
7531 ++handling_signal;
7532 #endif
7533 while (1)
7535 int nread;
7536 nread = read_avail_input (1);
7537 /* -1 means it's not ok to read the input now.
7538 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7539 0 means there was no keyboard input available. */
7540 if (nread <= 0)
7541 break;
7543 #ifdef HAVE_NS
7544 --handling_signal;
7545 #endif
7548 void
7549 process_pending_signals ()
7551 if (interrupt_input_pending)
7552 handle_async_input ();
7553 do_pending_atimers ();
7556 #ifdef SIGIO /* for entire page */
7557 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7559 static SIGTYPE
7560 input_available_signal (signo)
7561 int signo;
7563 /* Must preserve main program's value of errno. */
7564 int old_errno = errno;
7565 #if defined (USG) && !defined (POSIX_SIGNALS)
7566 /* USG systems forget handlers when they are used;
7567 must reestablish each time */
7568 signal (signo, input_available_signal);
7569 #endif /* USG */
7571 SIGNAL_THREAD_CHECK (signo);
7573 #ifdef SYNC_INPUT
7574 interrupt_input_pending = 1;
7575 pending_signals = 1;
7576 #endif
7578 if (input_available_clear_time)
7579 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
7581 #ifndef SYNC_INPUT
7582 handle_async_input ();
7583 #endif
7585 errno = old_errno;
7587 #endif /* SIGIO */
7589 /* Send ourselves a SIGIO.
7591 This function exists so that the UNBLOCK_INPUT macro in
7592 blockinput.h can have some way to take care of input we put off
7593 dealing with, without assuming that every file which uses
7594 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7595 void
7596 reinvoke_input_signal ()
7598 #ifdef SIGIO
7599 handle_async_input ();
7600 #endif
7605 /* User signal events. */
7607 struct user_signal_info
7609 /* Signal number. */
7610 int sig;
7612 /* Name of the signal. */
7613 char *name;
7615 /* Number of pending signals. */
7616 int npending;
7618 struct user_signal_info *next;
7621 /* List of user signals. */
7622 static struct user_signal_info *user_signals = NULL;
7624 void
7625 add_user_signal (sig, name)
7626 int sig;
7627 const char *name;
7629 struct user_signal_info *p;
7631 for (p = user_signals; p; p = p->next)
7632 if (p->sig == sig)
7633 /* Already added. */
7634 return;
7636 p = xmalloc (sizeof (struct user_signal_info));
7637 p->sig = sig;
7638 p->name = xstrdup (name);
7639 p->npending = 0;
7640 p->next = user_signals;
7641 user_signals = p;
7643 signal (sig, handle_user_signal);
7646 static SIGTYPE
7647 handle_user_signal (sig)
7648 int sig;
7650 int old_errno = errno;
7651 struct user_signal_info *p;
7653 #if defined (USG) && !defined (POSIX_SIGNALS)
7654 /* USG systems forget handlers when they are used;
7655 must reestablish each time */
7656 signal (sig, handle_user_signal);
7657 #endif
7659 SIGNAL_THREAD_CHECK (sig);
7661 for (p = user_signals; p; p = p->next)
7662 if (p->sig == sig)
7664 p->npending++;
7665 #ifdef SIGIO
7666 if (interrupt_input)
7667 kill (getpid (), SIGIO);
7668 else
7669 #endif
7671 /* Tell wait_reading_process_output that it needs to wake
7672 up and look around. */
7673 if (input_available_clear_time)
7674 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
7676 break;
7679 errno = old_errno;
7682 static char *
7683 find_user_signal_name (sig)
7684 int sig;
7686 struct user_signal_info *p;
7688 for (p = user_signals; p; p = p->next)
7689 if (p->sig == sig)
7690 return p->name;
7692 return NULL;
7695 static int
7696 store_user_signal_events ()
7698 struct user_signal_info *p;
7699 struct input_event buf;
7700 int nstored = 0;
7702 for (p = user_signals; p; p = p->next)
7703 if (p->npending > 0)
7705 SIGMASKTYPE mask;
7707 if (nstored == 0)
7709 bzero (&buf, sizeof buf);
7710 buf.kind = USER_SIGNAL_EVENT;
7711 buf.frame_or_window = selected_frame;
7713 nstored += p->npending;
7715 mask = sigblock (sigmask (p->sig));
7718 buf.code = p->sig;
7719 kbd_buffer_store_event (&buf);
7720 p->npending--;
7722 while (p->npending > 0);
7723 sigsetmask (mask);
7726 return nstored;
7730 static void menu_bar_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object, void*));
7731 static Lisp_Object menu_bar_one_keymap_changed_items;
7733 /* These variables hold the vector under construction within
7734 menu_bar_items and its subroutines, and the current index
7735 for storing into that vector. */
7736 static Lisp_Object menu_bar_items_vector;
7737 static int menu_bar_items_index;
7739 /* Return a vector of menu items for a menu bar, appropriate
7740 to the current buffer. Each item has three elements in the vector:
7741 KEY STRING MAPLIST.
7743 OLD is an old vector we can optionally reuse, or nil. */
7745 Lisp_Object
7746 menu_bar_items (old)
7747 Lisp_Object old;
7749 /* The number of keymaps we're scanning right now, and the number of
7750 keymaps we have allocated space for. */
7751 int nmaps;
7753 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7754 in the current keymaps, or nil where it is not a prefix. */
7755 Lisp_Object *maps;
7757 Lisp_Object def, tail;
7759 Lisp_Object result;
7761 int mapno;
7762 Lisp_Object oquit;
7764 int i;
7766 /* In order to build the menus, we need to call the keymap
7767 accessors. They all call QUIT. But this function is called
7768 during redisplay, during which a quit is fatal. So inhibit
7769 quitting while building the menus.
7770 We do this instead of specbind because (1) errors will clear it anyway
7771 and (2) this avoids risk of specpdl overflow. */
7772 oquit = Vinhibit_quit;
7773 Vinhibit_quit = Qt;
7775 if (!NILP (old))
7776 menu_bar_items_vector = old;
7777 else
7778 menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
7779 menu_bar_items_index = 0;
7781 /* Build our list of keymaps.
7782 If we recognize a function key and replace its escape sequence in
7783 keybuf with its symbol, or if the sequence starts with a mouse
7784 click and we need to switch buffers, we jump back here to rebuild
7785 the initial keymaps from the current buffer. */
7787 Lisp_Object *tmaps;
7789 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7790 if (!NILP (Voverriding_local_map_menu_flag))
7792 /* Yes, use them (if non-nil) as well as the global map. */
7793 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
7794 nmaps = 0;
7795 if (!NILP (current_kboard->Voverriding_terminal_local_map))
7796 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
7797 if (!NILP (Voverriding_local_map))
7798 maps[nmaps++] = Voverriding_local_map;
7800 else
7802 /* No, so use major and minor mode keymaps and keymap property.
7803 Note that menu-bar bindings in the local-map and keymap
7804 properties may not work reliable, as they are only
7805 recognized when the menu-bar (or mode-line) is updated,
7806 which does not normally happen after every command. */
7807 Lisp_Object tem;
7808 int nminor;
7809 nminor = current_minor_maps (NULL, &tmaps);
7810 maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
7811 nmaps = 0;
7812 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
7813 maps[nmaps++] = tem;
7814 bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
7815 nmaps += nminor;
7816 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
7818 maps[nmaps++] = current_global_map;
7821 /* Look up in each map the dummy prefix key `menu-bar'. */
7823 result = Qnil;
7825 for (mapno = nmaps - 1; mapno >= 0; mapno--)
7826 if (!NILP (maps[mapno]))
7828 def = get_keymap (access_keymap (maps[mapno], Qmenu_bar, 1, 0, 1),
7829 0, 1);
7830 if (CONSP (def))
7832 menu_bar_one_keymap_changed_items = Qnil;
7833 map_keymap (def, menu_bar_item, Qnil, NULL, 1);
7837 /* Move to the end those items that should be at the end. */
7839 for (tail = Vmenu_bar_final_items; CONSP (tail); tail = XCDR (tail))
7841 int i;
7842 int end = menu_bar_items_index;
7844 for (i = 0; i < end; i += 4)
7845 if (EQ (XCAR (tail), XVECTOR (menu_bar_items_vector)->contents[i]))
7847 Lisp_Object tem0, tem1, tem2, tem3;
7848 /* Move the item at index I to the end,
7849 shifting all the others forward. */
7850 tem0 = XVECTOR (menu_bar_items_vector)->contents[i + 0];
7851 tem1 = XVECTOR (menu_bar_items_vector)->contents[i + 1];
7852 tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
7853 tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
7854 if (end > i + 4)
7855 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
7856 &XVECTOR (menu_bar_items_vector)->contents[i],
7857 (end - i - 4) * sizeof (Lisp_Object));
7858 XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
7859 XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
7860 XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
7861 XVECTOR (menu_bar_items_vector)->contents[end - 1] = tem3;
7862 break;
7866 /* Add nil, nil, nil, nil at the end. */
7867 i = menu_bar_items_index;
7868 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
7869 menu_bar_items_vector = larger_vector (menu_bar_items_vector, 2 * i, Qnil);
7870 /* Add this item. */
7871 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
7872 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
7873 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
7874 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
7875 menu_bar_items_index = i;
7877 Vinhibit_quit = oquit;
7878 return menu_bar_items_vector;
7881 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7882 If there's already an item for KEY, add this DEF to it. */
7884 Lisp_Object item_properties;
7886 static void
7887 menu_bar_item (key, item, dummy1, dummy2)
7888 Lisp_Object key, item, dummy1;
7889 void *dummy2;
7891 struct gcpro gcpro1;
7892 int i;
7893 Lisp_Object tem;
7895 if (EQ (item, Qundefined))
7897 /* If a map has an explicit `undefined' as definition,
7898 discard any previously made menu bar item. */
7900 for (i = 0; i < menu_bar_items_index; i += 4)
7901 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
7903 if (menu_bar_items_index > i + 4)
7904 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
7905 &XVECTOR (menu_bar_items_vector)->contents[i],
7906 (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
7907 menu_bar_items_index -= 4;
7911 /* If this keymap has already contributed to this KEY,
7912 don't contribute to it a second time. */
7913 tem = Fmemq (key, menu_bar_one_keymap_changed_items);
7914 if (!NILP (tem) || NILP (item))
7915 return;
7917 menu_bar_one_keymap_changed_items
7918 = Fcons (key, menu_bar_one_keymap_changed_items);
7920 /* We add to menu_bar_one_keymap_changed_items before doing the
7921 parse_menu_item, so that if it turns out it wasn't a menu item,
7922 it still correctly hides any further menu item. */
7923 GCPRO1 (key);
7924 i = parse_menu_item (item, 1);
7925 UNGCPRO;
7926 if (!i)
7927 return;
7929 item = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
7931 /* Find any existing item for this KEY. */
7932 for (i = 0; i < menu_bar_items_index; i += 4)
7933 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
7934 break;
7936 /* If we did not find this KEY, add it at the end. */
7937 if (i == menu_bar_items_index)
7939 /* If vector is too small, get a bigger one. */
7940 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
7941 menu_bar_items_vector = larger_vector (menu_bar_items_vector, 2 * i, Qnil);
7942 /* Add this item. */
7943 XVECTOR (menu_bar_items_vector)->contents[i++] = key;
7944 XVECTOR (menu_bar_items_vector)->contents[i++]
7945 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
7946 XVECTOR (menu_bar_items_vector)->contents[i++] = Fcons (item, Qnil);
7947 XVECTOR (menu_bar_items_vector)->contents[i++] = make_number (0);
7948 menu_bar_items_index = i;
7950 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7951 else
7953 Lisp_Object old;
7954 old = XVECTOR (menu_bar_items_vector)->contents[i + 2];
7955 /* If the new and the old items are not both keymaps,
7956 the lookup will only find `item'. */
7957 item = Fcons (item, KEYMAPP (item) && KEYMAPP (XCAR (old)) ? old : Qnil);
7958 XVECTOR (menu_bar_items_vector)->contents[i + 2] = item;
7962 /* This is used as the handler when calling menu_item_eval_property. */
7963 static Lisp_Object
7964 menu_item_eval_property_1 (arg)
7965 Lisp_Object arg;
7967 /* If we got a quit from within the menu computation,
7968 quit all the way out of it. This takes care of C-] in the debugger. */
7969 if (CONSP (arg) && EQ (XCAR (arg), Qquit))
7970 Fsignal (Qquit, Qnil);
7972 return Qnil;
7975 /* Evaluate an expression and return the result (or nil if something
7976 went wrong). Used to evaluate dynamic parts of menu items. */
7977 Lisp_Object
7978 menu_item_eval_property (sexpr)
7979 Lisp_Object sexpr;
7981 int count = SPECPDL_INDEX ();
7982 Lisp_Object val;
7983 specbind (Qinhibit_redisplay, Qt);
7984 val = internal_condition_case_1 (Feval, sexpr, Qerror,
7985 menu_item_eval_property_1);
7986 return unbind_to (count, val);
7989 /* This function parses a menu item and leaves the result in the
7990 vector item_properties.
7991 ITEM is a key binding, a possible menu item.
7992 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7993 top level.
7994 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7995 parse_menu_item returns true if the item is a menu item and false
7996 otherwise. */
7999 parse_menu_item (item, inmenubar)
8000 Lisp_Object item;
8001 int inmenubar;
8003 Lisp_Object def, tem, item_string, start;
8004 Lisp_Object filter;
8005 Lisp_Object keyhint;
8006 int i;
8008 filter = Qnil;
8009 keyhint = Qnil;
8011 if (!CONSP (item))
8012 return 0;
8014 /* Create item_properties vector if necessary. */
8015 if (NILP (item_properties))
8016 item_properties
8017 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE + 1), Qnil);
8019 /* Initialize optional entries. */
8020 for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
8021 ASET (item_properties, i, Qnil);
8022 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
8024 /* Save the item here to protect it from GC. */
8025 ASET (item_properties, ITEM_PROPERTY_ITEM, item);
8027 item_string = XCAR (item);
8029 start = item;
8030 item = XCDR (item);
8031 if (STRINGP (item_string))
8033 /* Old format menu item. */
8034 ASET (item_properties, ITEM_PROPERTY_NAME, item_string);
8036 /* Maybe help string. */
8037 if (CONSP (item) && STRINGP (XCAR (item)))
8039 ASET (item_properties, ITEM_PROPERTY_HELP, XCAR (item));
8040 start = item;
8041 item = XCDR (item);
8044 /* Maybe an obsolete key binding cache. */
8045 if (CONSP (item) && CONSP (XCAR (item))
8046 && (NILP (XCAR (XCAR (item)))
8047 || VECTORP (XCAR (XCAR (item)))))
8048 item = XCDR (item);
8050 /* This is the real definition--the function to run. */
8051 ASET (item_properties, ITEM_PROPERTY_DEF, item);
8053 /* Get enable property, if any. */
8054 if (SYMBOLP (item))
8056 tem = Fget (item, Qmenu_enable);
8057 if (!NILP (Venable_disabled_menus_and_buttons))
8058 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
8059 else if (!NILP (tem))
8060 ASET (item_properties, ITEM_PROPERTY_ENABLE, tem);
8063 else if (EQ (item_string, Qmenu_item) && CONSP (item))
8065 /* New format menu item. */
8066 ASET (item_properties, ITEM_PROPERTY_NAME, XCAR (item));
8067 start = XCDR (item);
8068 if (CONSP (start))
8070 /* We have a real binding. */
8071 ASET (item_properties, ITEM_PROPERTY_DEF, XCAR (start));
8073 item = XCDR (start);
8074 /* Is there an obsolete cache list with key equivalences. */
8075 if (CONSP (item) && CONSP (XCAR (item)))
8076 item = XCDR (item);
8078 /* Parse properties. */
8079 while (CONSP (item) && CONSP (XCDR (item)))
8081 tem = XCAR (item);
8082 item = XCDR (item);
8084 if (EQ (tem, QCenable))
8086 if (!NILP (Venable_disabled_menus_and_buttons))
8087 ASET (item_properties, ITEM_PROPERTY_ENABLE, Qt);
8088 else
8089 ASET (item_properties, ITEM_PROPERTY_ENABLE, XCAR (item));
8091 else if (EQ (tem, QCvisible))
8093 /* If got a visible property and that evaluates to nil
8094 then ignore this item. */
8095 tem = menu_item_eval_property (XCAR (item));
8096 if (NILP (tem))
8097 return 0;
8099 else if (EQ (tem, QChelp))
8100 ASET (item_properties, ITEM_PROPERTY_HELP, XCAR (item));
8101 else if (EQ (tem, QCfilter))
8102 filter = item;
8103 else if (EQ (tem, QCkey_sequence))
8105 tem = XCAR (item);
8106 if (SYMBOLP (tem) || STRINGP (tem) || VECTORP (tem))
8107 /* Be GC protected. Set keyhint to item instead of tem. */
8108 keyhint = item;
8110 else if (EQ (tem, QCkeys))
8112 tem = XCAR (item);
8113 if (CONSP (tem) || STRINGP (tem))
8114 ASET (item_properties, ITEM_PROPERTY_KEYEQ, tem);
8116 else if (EQ (tem, QCbutton) && CONSP (XCAR (item)))
8118 Lisp_Object type;
8119 tem = XCAR (item);
8120 type = XCAR (tem);
8121 if (EQ (type, QCtoggle) || EQ (type, QCradio))
8123 ASET (item_properties, ITEM_PROPERTY_SELECTED,
8124 XCDR (tem));
8125 ASET (item_properties, ITEM_PROPERTY_TYPE, type);
8128 item = XCDR (item);
8131 else if (inmenubar || !NILP (start))
8132 return 0;
8134 else
8135 return 0; /* not a menu item */
8137 /* If item string is not a string, evaluate it to get string.
8138 If we don't get a string, skip this item. */
8139 item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
8140 if (!(STRINGP (item_string)))
8142 item_string = menu_item_eval_property (item_string);
8143 if (!STRINGP (item_string))
8144 return 0;
8145 ASET (item_properties, ITEM_PROPERTY_NAME, item_string);
8148 /* If got a filter apply it on definition. */
8149 def = AREF (item_properties, ITEM_PROPERTY_DEF);
8150 if (!NILP (filter))
8152 def = menu_item_eval_property (list2 (XCAR (filter),
8153 list2 (Qquote, def)));
8155 ASET (item_properties, ITEM_PROPERTY_DEF, def);
8158 /* Enable or disable selection of item. */
8159 tem = AREF (item_properties, ITEM_PROPERTY_ENABLE);
8160 if (!EQ (tem, Qt))
8162 tem = menu_item_eval_property (tem);
8163 if (inmenubar && NILP (tem))
8164 return 0; /* Ignore disabled items in menu bar. */
8165 ASET (item_properties, ITEM_PROPERTY_ENABLE, tem);
8168 /* If we got no definition, this item is just unselectable text which
8169 is OK in a submenu but not in the menubar. */
8170 if (NILP (def))
8171 return (inmenubar ? 0 : 1);
8173 /* See if this is a separate pane or a submenu. */
8174 def = AREF (item_properties, ITEM_PROPERTY_DEF);
8175 tem = get_keymap (def, 0, 1);
8176 /* For a subkeymap, just record its details and exit. */
8177 if (CONSP (tem))
8179 ASET (item_properties, ITEM_PROPERTY_MAP, tem);
8180 ASET (item_properties, ITEM_PROPERTY_DEF, tem);
8181 return 1;
8184 /* At the top level in the menu bar, do likewise for commands also.
8185 The menu bar does not display equivalent key bindings anyway.
8186 ITEM_PROPERTY_DEF is already set up properly. */
8187 if (inmenubar > 0)
8188 return 1;
8190 { /* This is a command. See if there is an equivalent key binding. */
8191 Lisp_Object keyeq = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
8193 /* The previous code preferred :key-sequence to :keys, so we
8194 preserve this behavior. */
8195 if (STRINGP (keyeq) && !CONSP (keyhint))
8196 keyeq = concat2 (build_string (" "), Fsubstitute_command_keys (keyeq));
8197 else
8199 Lisp_Object prefix = keyeq;
8200 Lisp_Object keys = Qnil;
8202 if (CONSP (prefix))
8204 def = XCAR (prefix);
8205 prefix = XCDR (prefix);
8207 else
8208 def = AREF (item_properties, ITEM_PROPERTY_DEF);
8210 if (CONSP (keyhint) && !NILP (XCAR (keyhint)))
8212 keys = XCAR (keyhint);
8213 tem = Fkey_binding (keys, Qnil, Qnil, Qnil);
8215 /* We have a suggested key. Is it bound to the command? */
8216 if (NILP (tem)
8217 || (!EQ (tem, def)
8218 /* If the command is an alias for another
8219 (such as lmenu.el set it up), check if the
8220 original command matches the cached command. */
8221 && !(SYMBOLP (def) && EQ (tem, XSYMBOL (def)->function))))
8222 keys = Qnil;
8225 if (NILP (keys))
8226 keys = Fwhere_is_internal (def, Qnil, Qt, Qnil, Qnil);
8228 if (!NILP (keys))
8230 tem = Fkey_description (keys, Qnil);
8231 if (CONSP (prefix))
8233 if (STRINGP (XCAR (prefix)))
8234 tem = concat2 (XCAR (prefix), tem);
8235 if (STRINGP (XCDR (prefix)))
8236 tem = concat2 (tem, XCDR (prefix));
8238 keyeq = concat2 (build_string (" "), tem);
8239 /* keyeq = concat3(build_string(" ("),tem,build_string(")")); */
8241 else
8242 keyeq = Qnil;
8245 /* If we have an equivalent key binding, use that. */
8246 ASET (item_properties, ITEM_PROPERTY_KEYEQ, keyeq);
8249 /* Include this when menu help is implemented.
8250 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
8251 if (!(NILP (tem) || STRINGP (tem)))
8253 tem = menu_item_eval_property (tem);
8254 if (!STRINGP (tem))
8255 tem = Qnil;
8256 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
8260 /* Handle radio buttons or toggle boxes. */
8261 tem = AREF (item_properties, ITEM_PROPERTY_SELECTED);
8262 if (!NILP (tem))
8263 ASET (item_properties, ITEM_PROPERTY_SELECTED,
8264 menu_item_eval_property (tem));
8266 return 1;
8271 /***********************************************************************
8272 Tool-bars
8273 ***********************************************************************/
8275 /* A vector holding tool bar items while they are parsed in function
8276 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
8277 in the vector. */
8279 static Lisp_Object tool_bar_items_vector;
8281 /* A vector holding the result of parse_tool_bar_item. Layout is like
8282 the one for a single item in tool_bar_items_vector. */
8284 static Lisp_Object tool_bar_item_properties;
8286 /* Next free index in tool_bar_items_vector. */
8288 static int ntool_bar_items;
8290 /* The symbols `tool-bar', `:image' and `:rtl'. */
8292 extern Lisp_Object Qtool_bar;
8293 Lisp_Object QCimage;
8294 Lisp_Object Qrtl;
8296 /* Function prototypes. */
8298 static void init_tool_bar_items P_ ((Lisp_Object));
8299 static void process_tool_bar_item P_ ((Lisp_Object, Lisp_Object, Lisp_Object, void*));
8300 static int parse_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
8301 static void append_tool_bar_item P_ ((void));
8304 /* Return a vector of tool bar items for keymaps currently in effect.
8305 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
8306 tool bar items found. */
8308 Lisp_Object
8309 tool_bar_items (reuse, nitems)
8310 Lisp_Object reuse;
8311 int *nitems;
8313 Lisp_Object *maps;
8314 int nmaps, i;
8315 Lisp_Object oquit;
8316 Lisp_Object *tmaps;
8318 *nitems = 0;
8320 /* In order to build the menus, we need to call the keymap
8321 accessors. They all call QUIT. But this function is called
8322 during redisplay, during which a quit is fatal. So inhibit
8323 quitting while building the menus. We do this instead of
8324 specbind because (1) errors will clear it anyway and (2) this
8325 avoids risk of specpdl overflow. */
8326 oquit = Vinhibit_quit;
8327 Vinhibit_quit = Qt;
8329 /* Initialize tool_bar_items_vector and protect it from GC. */
8330 init_tool_bar_items (reuse);
8332 /* Build list of keymaps in maps. Set nmaps to the number of maps
8333 to process. */
8335 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8336 if (!NILP (Voverriding_local_map_menu_flag))
8338 /* Yes, use them (if non-nil) as well as the global map. */
8339 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
8340 nmaps = 0;
8341 if (!NILP (current_kboard->Voverriding_terminal_local_map))
8342 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
8343 if (!NILP (Voverriding_local_map))
8344 maps[nmaps++] = Voverriding_local_map;
8346 else
8348 /* No, so use major and minor mode keymaps and keymap property.
8349 Note that tool-bar bindings in the local-map and keymap
8350 properties may not work reliable, as they are only
8351 recognized when the tool-bar (or mode-line) is updated,
8352 which does not normally happen after every command. */
8353 Lisp_Object tem;
8354 int nminor;
8355 nminor = current_minor_maps (NULL, &tmaps);
8356 maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
8357 nmaps = 0;
8358 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
8359 maps[nmaps++] = tem;
8360 bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
8361 nmaps += nminor;
8362 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
8365 /* Add global keymap at the end. */
8366 maps[nmaps++] = current_global_map;
8368 /* Process maps in reverse order and look up in each map the prefix
8369 key `tool-bar'. */
8370 for (i = nmaps - 1; i >= 0; --i)
8371 if (!NILP (maps[i]))
8373 Lisp_Object keymap;
8375 keymap = get_keymap (access_keymap (maps[i], Qtool_bar, 1, 0, 1), 0, 1);
8376 if (CONSP (keymap))
8377 map_keymap (keymap, process_tool_bar_item, Qnil, NULL, 1);
8380 Vinhibit_quit = oquit;
8381 *nitems = ntool_bar_items / TOOL_BAR_ITEM_NSLOTS;
8382 return tool_bar_items_vector;
8386 /* Process the definition of KEY which is DEF. */
8388 static void
8389 process_tool_bar_item (key, def, data, args)
8390 Lisp_Object key, def, data;
8391 void *args;
8393 int i;
8394 extern Lisp_Object Qundefined;
8395 struct gcpro gcpro1, gcpro2;
8397 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8398 eval. */
8399 GCPRO2 (key, def);
8401 if (EQ (def, Qundefined))
8403 /* If a map has an explicit `undefined' as definition,
8404 discard any previously made item. */
8405 for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
8407 Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
8409 if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
8411 if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
8412 bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
8413 ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
8414 * sizeof (Lisp_Object)));
8415 ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
8416 break;
8420 else if (parse_tool_bar_item (key, def))
8421 /* Append a new tool bar item to tool_bar_items_vector. Accept
8422 more than one definition for the same key. */
8423 append_tool_bar_item ();
8425 UNGCPRO;
8429 /* Parse a tool bar item specification ITEM for key KEY and return the
8430 result in tool_bar_item_properties. Value is zero if ITEM is
8431 invalid.
8433 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8435 CAPTION is the caption of the item, If it's not a string, it is
8436 evaluated to get a string.
8438 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8439 as binding are currently ignored.
8441 The following properties are recognized:
8443 - `:enable FORM'.
8445 FORM is evaluated and specifies whether the tool bar item is
8446 enabled or disabled.
8448 - `:visible FORM'
8450 FORM is evaluated and specifies whether the tool bar item is visible.
8452 - `:filter FUNCTION'
8454 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8455 result is stored as the new binding.
8457 - `:button (TYPE SELECTED)'
8459 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8460 and specifies whether the button is selected (pressed) or not.
8462 - `:image IMAGES'
8464 IMAGES is either a single image specification or a vector of four
8465 image specifications. See enum tool_bar_item_images.
8467 - `:help HELP-STRING'.
8469 Gives a help string to display for the tool bar item. */
8471 static int
8472 parse_tool_bar_item (key, item)
8473 Lisp_Object key, item;
8475 /* Access slot with index IDX of vector tool_bar_item_properties. */
8476 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8478 Lisp_Object filter = Qnil;
8479 Lisp_Object caption;
8480 int i;
8482 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8483 Rule out items that aren't lists, don't start with
8484 `menu-item' or whose rest following `tool-bar-item' is not a
8485 list. */
8486 if (!CONSP (item)
8487 || !EQ (XCAR (item), Qmenu_item)
8488 || (item = XCDR (item),
8489 !CONSP (item)))
8490 return 0;
8492 /* Create tool_bar_item_properties vector if necessary. Reset it to
8493 defaults. */
8494 if (VECTORP (tool_bar_item_properties))
8496 for (i = 0; i < TOOL_BAR_ITEM_NSLOTS; ++i)
8497 PROP (i) = Qnil;
8499 else
8500 tool_bar_item_properties
8501 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS), Qnil);
8503 /* Set defaults. */
8504 PROP (TOOL_BAR_ITEM_KEY) = key;
8505 PROP (TOOL_BAR_ITEM_ENABLED_P) = Qt;
8507 /* Get the caption of the item. If the caption is not a string,
8508 evaluate it to get a string. If we don't get a string, skip this
8509 item. */
8510 caption = XCAR (item);
8511 if (!STRINGP (caption))
8513 caption = menu_item_eval_property (caption);
8514 if (!STRINGP (caption))
8515 return 0;
8517 PROP (TOOL_BAR_ITEM_CAPTION) = caption;
8519 /* Give up if rest following the caption is not a list. */
8520 item = XCDR (item);
8521 if (!CONSP (item))
8522 return 0;
8524 /* Store the binding. */
8525 PROP (TOOL_BAR_ITEM_BINDING) = XCAR (item);
8526 item = XCDR (item);
8528 /* Ignore cached key binding, if any. */
8529 if (CONSP (item) && CONSP (XCAR (item)))
8530 item = XCDR (item);
8532 /* Process the rest of the properties. */
8533 for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
8535 Lisp_Object key, value;
8537 key = XCAR (item);
8538 value = XCAR (XCDR (item));
8540 if (EQ (key, QCenable))
8542 /* `:enable FORM'. */
8543 if (!NILP (Venable_disabled_menus_and_buttons))
8544 PROP (TOOL_BAR_ITEM_ENABLED_P) = Qt;
8545 else
8546 PROP (TOOL_BAR_ITEM_ENABLED_P) = value;
8548 else if (EQ (key, QCvisible))
8550 /* `:visible FORM'. If got a visible property and that
8551 evaluates to nil then ignore this item. */
8552 if (NILP (menu_item_eval_property (value)))
8553 return 0;
8555 else if (EQ (key, QChelp))
8556 /* `:help HELP-STRING'. */
8557 PROP (TOOL_BAR_ITEM_HELP) = value;
8558 else if (EQ (key, QCfilter))
8559 /* ':filter FORM'. */
8560 filter = value;
8561 else if (EQ (key, QCbutton) && CONSP (value))
8563 /* `:button (TYPE . SELECTED)'. */
8564 Lisp_Object type, selected;
8566 type = XCAR (value);
8567 selected = XCDR (value);
8568 if (EQ (type, QCtoggle) || EQ (type, QCradio))
8570 PROP (TOOL_BAR_ITEM_SELECTED_P) = selected;
8571 PROP (TOOL_BAR_ITEM_TYPE) = type;
8574 else if (EQ (key, QCimage)
8575 && (CONSP (value)
8576 || (VECTORP (value) && XVECTOR (value)->size == 4)))
8577 /* Value is either a single image specification or a vector
8578 of 4 such specifications for the different button states. */
8579 PROP (TOOL_BAR_ITEM_IMAGES) = value;
8580 else if (EQ (key, Qrtl))
8581 /* ':rtl STRING' */
8582 PROP (TOOL_BAR_ITEM_RTL_IMAGE) = value;
8585 /* If got a filter apply it on binding. */
8586 if (!NILP (filter))
8587 PROP (TOOL_BAR_ITEM_BINDING)
8588 = menu_item_eval_property (list2 (filter,
8589 list2 (Qquote,
8590 PROP (TOOL_BAR_ITEM_BINDING))));
8592 /* See if the binding is a keymap. Give up if it is. */
8593 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
8594 return 0;
8596 /* Enable or disable selection of item. */
8597 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P), Qt))
8598 PROP (TOOL_BAR_ITEM_ENABLED_P)
8599 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P));
8601 /* Handle radio buttons or toggle boxes. */
8602 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P)))
8603 PROP (TOOL_BAR_ITEM_SELECTED_P)
8604 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P));
8606 return 1;
8608 #undef PROP
8612 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8613 that can be reused. */
8615 static void
8616 init_tool_bar_items (reuse)
8617 Lisp_Object reuse;
8619 if (VECTORP (reuse))
8620 tool_bar_items_vector = reuse;
8621 else
8622 tool_bar_items_vector = Fmake_vector (make_number (64), Qnil);
8623 ntool_bar_items = 0;
8627 /* Append parsed tool bar item properties from
8628 tool_bar_item_properties */
8630 static void
8631 append_tool_bar_item ()
8633 Lisp_Object *to, *from;
8635 /* Enlarge tool_bar_items_vector if necessary. */
8636 if (ntool_bar_items + TOOL_BAR_ITEM_NSLOTS
8637 >= XVECTOR (tool_bar_items_vector)->size)
8638 tool_bar_items_vector
8639 = larger_vector (tool_bar_items_vector,
8640 2 * XVECTOR (tool_bar_items_vector)->size, Qnil);
8642 /* Append entries from tool_bar_item_properties to the end of
8643 tool_bar_items_vector. */
8644 to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
8645 from = XVECTOR (tool_bar_item_properties)->contents;
8646 bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
8647 ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
8654 /* Read a character using menus based on maps in the array MAPS.
8655 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8656 Return t if we displayed a menu but the user rejected it.
8658 PREV_EVENT is the previous input event, or nil if we are reading
8659 the first event of a key sequence.
8661 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8662 if we used a mouse menu to read the input, or zero otherwise. If
8663 USED_MOUSE_MENU is null, we don't dereference it.
8665 The prompting is done based on the prompt-string of the map
8666 and the strings associated with various map elements.
8668 This can be done with X menus or with menus put in the minibuf.
8669 These are done in different ways, depending on how the input will be read.
8670 Menus using X are done after auto-saving in read-char, getting the input
8671 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8672 and do auto-saving in the inner call of read_char. */
8674 static Lisp_Object
8675 read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
8676 int nmaps;
8677 Lisp_Object *maps;
8678 Lisp_Object prev_event;
8679 int *used_mouse_menu;
8681 int mapno;
8683 if (used_mouse_menu)
8684 *used_mouse_menu = 0;
8686 /* Use local over global Menu maps */
8688 if (! menu_prompting)
8689 return Qnil;
8691 /* Optionally disregard all but the global map. */
8692 if (inhibit_local_menu_bar_menus)
8694 maps += (nmaps - 1);
8695 nmaps = 1;
8698 #ifdef HAVE_MENUS
8699 /* If we got to this point via a mouse click,
8700 use a real menu for mouse selection. */
8701 if (EVENT_HAS_PARAMETERS (prev_event)
8702 && !EQ (XCAR (prev_event), Qmenu_bar)
8703 && !EQ (XCAR (prev_event), Qtool_bar))
8705 /* Display the menu and get the selection. */
8706 Lisp_Object *realmaps
8707 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
8708 Lisp_Object value;
8709 int nmaps1 = 0;
8711 /* Use the maps that are not nil. */
8712 for (mapno = 0; mapno < nmaps; mapno++)
8713 if (!NILP (maps[mapno]))
8714 realmaps[nmaps1++] = maps[mapno];
8716 value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
8717 if (CONSP (value))
8719 Lisp_Object tem;
8721 record_menu_key (XCAR (value));
8723 /* If we got multiple events, unread all but
8724 the first.
8725 There is no way to prevent those unread events
8726 from showing up later in last_nonmenu_event.
8727 So turn symbol and integer events into lists,
8728 to indicate that they came from a mouse menu,
8729 so that when present in last_nonmenu_event
8730 they won't confuse things. */
8731 for (tem = XCDR (value); CONSP (tem); tem = XCDR (tem))
8733 record_menu_key (XCAR (tem));
8734 if (SYMBOLP (XCAR (tem))
8735 || INTEGERP (XCAR (tem)))
8736 XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
8739 /* If we got more than one event, put all but the first
8740 onto this list to be read later.
8741 Return just the first event now. */
8742 Vunread_command_events
8743 = nconc2 (XCDR (value), Vunread_command_events);
8744 value = XCAR (value);
8746 else if (NILP (value))
8747 value = Qt;
8748 if (used_mouse_menu)
8749 *used_mouse_menu = 1;
8750 return value;
8752 #endif /* HAVE_MENUS */
8753 return Qnil ;
8756 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8757 We make this bigger when necessary, and never free it. */
8758 static char *read_char_minibuf_menu_text;
8759 /* Size of that buffer. */
8760 static int read_char_minibuf_menu_width;
8762 static Lisp_Object
8763 read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
8764 int commandflag ;
8765 int nmaps;
8766 Lisp_Object *maps;
8768 int mapno;
8769 register Lisp_Object name;
8770 int nlength;
8771 /* FIXME: Use the minibuffer's frame width. */
8772 int width = FRAME_COLS (SELECTED_FRAME ()) - 4;
8773 int idx = -1;
8774 int nobindings = 1;
8775 Lisp_Object rest, vector;
8776 char *menu;
8778 vector = Qnil;
8779 name = Qnil;
8781 if (! menu_prompting)
8782 return Qnil;
8784 /* Get the menu name from the first map that has one (a prompt string). */
8785 for (mapno = 0; mapno < nmaps; mapno++)
8787 name = Fkeymap_prompt (maps[mapno]);
8788 if (!NILP (name))
8789 break;
8792 /* If we don't have any menus, just read a character normally. */
8793 if (!STRINGP (name))
8794 return Qnil;
8796 /* Make sure we have a big enough buffer for the menu text. */
8797 width = max (width, SBYTES (name));
8798 if (read_char_minibuf_menu_text == 0)
8800 read_char_minibuf_menu_width = width + 4;
8801 read_char_minibuf_menu_text = (char *) xmalloc (width + 4);
8803 else if (width + 4 > read_char_minibuf_menu_width)
8805 read_char_minibuf_menu_width = width + 4;
8806 read_char_minibuf_menu_text
8807 = (char *) xrealloc (read_char_minibuf_menu_text, width + 4);
8809 menu = read_char_minibuf_menu_text;
8811 /* Prompt string always starts with map's prompt, and a space. */
8812 strcpy (menu, SDATA (name));
8813 nlength = SBYTES (name);
8814 menu[nlength++] = ':';
8815 menu[nlength++] = ' ';
8816 menu[nlength] = 0;
8818 /* Start prompting at start of first map. */
8819 mapno = 0;
8820 rest = maps[mapno];
8822 /* Present the documented bindings, a line at a time. */
8823 while (1)
8825 int notfirst = 0;
8826 int i = nlength;
8827 Lisp_Object obj;
8828 int ch;
8829 Lisp_Object orig_defn_macro;
8831 /* Loop over elements of map. */
8832 while (i < width)
8834 Lisp_Object elt;
8836 /* If reached end of map, start at beginning of next map. */
8837 if (NILP (rest))
8839 mapno++;
8840 /* At end of last map, wrap around to first map if just starting,
8841 or end this line if already have something on it. */
8842 if (mapno == nmaps)
8844 mapno = 0;
8845 if (notfirst || nobindings) break;
8847 rest = maps[mapno];
8850 /* Look at the next element of the map. */
8851 if (idx >= 0)
8852 elt = XVECTOR (vector)->contents[idx];
8853 else
8854 elt = Fcar_safe (rest);
8856 if (idx < 0 && VECTORP (elt))
8858 /* If we found a dense table in the keymap,
8859 advanced past it, but start scanning its contents. */
8860 rest = Fcdr_safe (rest);
8861 vector = elt;
8862 idx = 0;
8864 else
8866 /* An ordinary element. */
8867 Lisp_Object event, tem;
8869 if (idx < 0)
8871 event = Fcar_safe (elt); /* alist */
8872 elt = Fcdr_safe (elt);
8874 else
8876 XSETINT (event, idx); /* vector */
8879 /* Ignore the element if it has no prompt string. */
8880 if (INTEGERP (event) && parse_menu_item (elt, -1))
8882 /* 1 if the char to type matches the string. */
8883 int char_matches;
8884 Lisp_Object upcased_event, downcased_event;
8885 Lisp_Object desc = Qnil;
8886 Lisp_Object s
8887 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
8889 upcased_event = Fupcase (event);
8890 downcased_event = Fdowncase (event);
8891 char_matches = (XINT (upcased_event) == SREF (s, 0)
8892 || XINT (downcased_event) == SREF (s, 0));
8893 if (! char_matches)
8894 desc = Fsingle_key_description (event, Qnil);
8896 #if 0 /* It is redundant to list the equivalent key bindings because
8897 the prefix is what the user has already typed. */
8899 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
8900 if (!NILP (tem))
8901 /* Insert equivalent keybinding. */
8902 s = concat2 (s, tem);
8903 #endif
8905 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
8906 if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
8908 /* Insert button prefix. */
8909 Lisp_Object selected
8910 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
8911 if (EQ (tem, QCradio))
8912 tem = build_string (NILP (selected) ? "(*) " : "( ) ");
8913 else
8914 tem = build_string (NILP (selected) ? "[X] " : "[ ] ");
8915 s = concat2 (tem, s);
8919 /* If we have room for the prompt string, add it to this line.
8920 If this is the first on the line, always add it. */
8921 if ((SCHARS (s) + i + 2
8922 + (char_matches ? 0 : SCHARS (desc) + 3))
8923 < width
8924 || !notfirst)
8926 int thiswidth;
8928 /* Punctuate between strings. */
8929 if (notfirst)
8931 strcpy (menu + i, ", ");
8932 i += 2;
8934 notfirst = 1;
8935 nobindings = 0 ;
8937 /* If the char to type doesn't match the string's
8938 first char, explicitly show what char to type. */
8939 if (! char_matches)
8941 /* Add as much of string as fits. */
8942 thiswidth = SCHARS (desc);
8943 if (thiswidth + i > width)
8944 thiswidth = width - i;
8945 bcopy (SDATA (desc), menu + i, thiswidth);
8946 i += thiswidth;
8947 strcpy (menu + i, " = ");
8948 i += 3;
8951 /* Add as much of string as fits. */
8952 thiswidth = SCHARS (s);
8953 if (thiswidth + i > width)
8954 thiswidth = width - i;
8955 bcopy (SDATA (s), menu + i, thiswidth);
8956 i += thiswidth;
8957 menu[i] = 0;
8959 else
8961 /* If this element does not fit, end the line now,
8962 and save the element for the next line. */
8963 strcpy (menu + i, "...");
8964 break;
8968 /* Move past this element. */
8969 if (idx >= 0 && idx + 1 >= XVECTOR (vector)->size)
8970 /* Handle reaching end of dense table. */
8971 idx = -1;
8972 if (idx >= 0)
8973 idx++;
8974 else
8975 rest = Fcdr_safe (rest);
8979 /* Prompt with that and read response. */
8980 message2_nolog (menu, strlen (menu),
8981 ! NILP (current_buffer->enable_multibyte_characters));
8983 /* Make believe its not a keyboard macro in case the help char
8984 is pressed. Help characters are not recorded because menu prompting
8985 is not used on replay.
8987 orig_defn_macro = current_kboard->defining_kbd_macro;
8988 current_kboard->defining_kbd_macro = Qnil;
8990 obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
8991 while (BUFFERP (obj));
8992 current_kboard->defining_kbd_macro = orig_defn_macro;
8994 if (!INTEGERP (obj))
8995 return obj;
8996 else if (XINT (obj) == -2)
8997 return obj;
8998 else
8999 ch = XINT (obj);
9001 if (! EQ (obj, menu_prompt_more_char)
9002 && (!INTEGERP (menu_prompt_more_char)
9003 || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
9005 if (!NILP (current_kboard->defining_kbd_macro))
9006 store_kbd_macro_char (obj);
9007 return obj;
9009 /* Help char - go round again */
9013 /* Reading key sequences. */
9015 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
9016 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
9017 keymap, or nil otherwise. Return the index of the first keymap in
9018 which KEY has any binding, or NMAPS if no map has a binding.
9020 If KEY is a meta ASCII character, treat it like meta-prefix-char
9021 followed by the corresponding non-meta character. Keymaps in
9022 CURRENT with non-prefix bindings for meta-prefix-char become nil in
9023 NEXT.
9025 If KEY has no bindings in any of the CURRENT maps, NEXT is left
9026 unmodified.
9028 NEXT may be the same array as CURRENT. */
9030 static int
9031 follow_key (key, nmaps, current, defs, next)
9032 Lisp_Object key;
9033 Lisp_Object *current, *defs, *next;
9034 int nmaps;
9036 int i, first_binding;
9038 first_binding = nmaps;
9039 for (i = nmaps - 1; i >= 0; i--)
9041 if (! NILP (current[i]))
9043 defs[i] = access_keymap (current[i], key, 1, 0, 1);
9044 if (! NILP (defs[i]))
9045 first_binding = i;
9047 else
9048 defs[i] = Qnil;
9051 /* Given the set of bindings we've found, produce the next set of maps. */
9052 if (first_binding < nmaps)
9053 for (i = 0; i < nmaps; i++)
9054 next[i] = NILP (defs[i]) ? Qnil : get_keymap (defs[i], 0, 1);
9056 return first_binding;
9059 /* Structure used to keep track of partial application of key remapping
9060 such as Vfunction_key_map and Vkey_translation_map. */
9061 typedef struct keyremap
9063 /* This is the map originally specified for this use. */
9064 Lisp_Object parent;
9065 /* This is a submap reached by looking up, in PARENT,
9066 the events from START to END. */
9067 Lisp_Object map;
9068 /* Positions [START, END) in the key sequence buffer
9069 are the key that we have scanned so far.
9070 Those events are the ones that we will replace
9071 if PAREHT maps them into a key sequence. */
9072 int start, end;
9073 } keyremap;
9075 /* Lookup KEY in MAP.
9076 MAP is a keymap mapping keys to key vectors or functions.
9077 If the mapping is a function and DO_FUNCTION is non-zero, then
9078 the function is called with PROMPT as parameter and its return
9079 value is used as the return value of this function (after checking
9080 that it is indeed a vector). */
9082 static Lisp_Object
9083 access_keymap_keyremap (map, key, prompt, do_funcall)
9084 Lisp_Object map, key, prompt;
9085 int do_funcall;
9087 Lisp_Object next;
9089 next = access_keymap (map, key, 1, 0, 1);
9091 /* Handle symbol with autoload definition. */
9092 if (SYMBOLP (next) && !NILP (Ffboundp (next))
9093 && CONSP (XSYMBOL (next)->function)
9094 && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
9095 do_autoload (XSYMBOL (next)->function, next);
9097 /* Handle a symbol whose function definition is a keymap
9098 or an array. */
9099 if (SYMBOLP (next) && !NILP (Ffboundp (next))
9100 && (ARRAYP (XSYMBOL (next)->function)
9101 || KEYMAPP (XSYMBOL (next)->function)))
9102 next = XSYMBOL (next)->function;
9104 /* If the keymap gives a function, not an
9105 array, then call the function with one arg and use
9106 its value instead. */
9107 if (SYMBOLP (next) && !NILP (Ffboundp (next)) && do_funcall)
9109 Lisp_Object tem;
9110 tem = next;
9112 next = call1 (next, prompt);
9113 /* If the function returned something invalid,
9114 barf--don't ignore it.
9115 (To ignore it safely, we would need to gcpro a bunch of
9116 other variables.) */
9117 if (! (VECTORP (next) || STRINGP (next)))
9118 error ("Function %s returns invalid key sequence", tem);
9120 return next;
9123 /* Do one step of the key remapping used for function-key-map and
9124 key-translation-map:
9125 KEYBUF is the buffer holding the input events.
9126 BUFSIZE is its maximum size.
9127 FKEY is a pointer to the keyremap structure to use.
9128 INPUT is the index of the last element in KEYBUF.
9129 DOIT if non-zero says that the remapping can actually take place.
9130 DIFF is used to return the number of keys added/removed by the remapping.
9131 PARENT is the root of the keymap.
9132 PROMPT is the prompt to use if the remapping happens through a function.
9133 The return value is non-zero if the remapping actually took place. */
9135 static int
9136 keyremap_step (keybuf, bufsize, fkey, input, doit, diff, prompt)
9137 Lisp_Object *keybuf, prompt;
9138 keyremap *fkey;
9139 int input, doit, *diff, bufsize;
9141 Lisp_Object next, key;
9143 key = keybuf[fkey->end++];
9145 if (KEYMAPP (fkey->parent))
9146 next = access_keymap_keyremap (fkey->map, key, prompt, doit);
9147 else
9148 next = Qnil;
9150 /* If keybuf[fkey->start..fkey->end] is bound in the
9151 map and we're in a position to do the key remapping, replace it with
9152 the binding and restart with fkey->start at the end. */
9153 if ((VECTORP (next) || STRINGP (next)) && doit)
9155 int len = XFASTINT (Flength (next));
9156 int i;
9158 *diff = len - (fkey->end - fkey->start);
9160 if (input + *diff >= bufsize)
9161 error ("Key sequence too long");
9163 /* Shift the keys that follow fkey->end. */
9164 if (*diff < 0)
9165 for (i = fkey->end; i < input; i++)
9166 keybuf[i + *diff] = keybuf[i];
9167 else if (*diff > 0)
9168 for (i = input - 1; i >= fkey->end; i--)
9169 keybuf[i + *diff] = keybuf[i];
9170 /* Overwrite the old keys with the new ones. */
9171 for (i = 0; i < len; i++)
9172 keybuf[fkey->start + i]
9173 = Faref (next, make_number (i));
9175 fkey->start = fkey->end += *diff;
9176 fkey->map = fkey->parent;
9178 return 1;
9181 fkey->map = get_keymap (next, 0, 1);
9183 /* If we no longer have a bound suffix, try a new position for
9184 fkey->start. */
9185 if (!CONSP (fkey->map))
9187 fkey->end = ++fkey->start;
9188 fkey->map = fkey->parent;
9190 return 0;
9193 /* Read a sequence of keys that ends with a non prefix character,
9194 storing it in KEYBUF, a buffer of size BUFSIZE.
9195 Prompt with PROMPT.
9196 Return the length of the key sequence stored.
9197 Return -1 if the user rejected a command menu.
9199 Echo starting immediately unless `prompt' is 0.
9201 Where a key sequence ends depends on the currently active keymaps.
9202 These include any minor mode keymaps active in the current buffer,
9203 the current buffer's local map, and the global map.
9205 If a key sequence has no other bindings, we check Vfunction_key_map
9206 to see if some trailing subsequence might be the beginning of a
9207 function key's sequence. If so, we try to read the whole function
9208 key, and substitute its symbolic name into the key sequence.
9210 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
9211 `double-' events into similar click events, if that would make them
9212 bound. We try to turn `triple-' events first into `double-' events,
9213 then into clicks.
9215 If we get a mouse click in a mode line, vertical divider, or other
9216 non-text area, we treat the click as if it were prefixed by the
9217 symbol denoting that area - `mode-line', `vertical-line', or
9218 whatever.
9220 If the sequence starts with a mouse click, we read the key sequence
9221 with respect to the buffer clicked on, not the current buffer.
9223 If the user switches frames in the midst of a key sequence, we put
9224 off the switch-frame event until later; the next call to
9225 read_char will return it.
9227 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
9228 from the selected window's buffer. */
9230 static int
9231 read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
9232 can_return_switch_frame, fix_current_buffer)
9233 Lisp_Object *keybuf;
9234 int bufsize;
9235 Lisp_Object prompt;
9236 int dont_downcase_last;
9237 int can_return_switch_frame;
9238 int fix_current_buffer;
9240 Lisp_Object from_string;
9241 int count = SPECPDL_INDEX ();
9243 /* How many keys there are in the current key sequence. */
9244 int t;
9246 /* The length of the echo buffer when we started reading, and
9247 the length of this_command_keys when we started reading. */
9248 int echo_start;
9249 int keys_start;
9251 /* The number of keymaps we're scanning right now, and the number of
9252 keymaps we have allocated space for. */
9253 int nmaps;
9254 int nmaps_allocated = 0;
9256 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
9257 the current keymaps. */
9258 Lisp_Object *defs = NULL;
9260 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
9261 in the current keymaps, or nil where it is not a prefix. */
9262 Lisp_Object *submaps = NULL;
9264 /* The local map to start out with at start of key sequence. */
9265 Lisp_Object orig_local_map;
9267 /* The map from the `keymap' property to start out with at start of
9268 key sequence. */
9269 Lisp_Object orig_keymap;
9271 /* 1 if we have already considered switching to the local-map property
9272 of the place where a mouse click occurred. */
9273 int localized_local_map = 0;
9275 /* The index in submaps[] of the first keymap that has a binding for
9276 this key sequence. In other words, the lowest i such that
9277 submaps[i] is non-nil. */
9278 int first_binding;
9279 /* Index of the first key that has no binding.
9280 It is useless to try fkey.start larger than that. */
9281 int first_unbound;
9283 /* If t < mock_input, then KEYBUF[t] should be read as the next
9284 input key.
9286 We use this to recover after recognizing a function key. Once we
9287 realize that a suffix of the current key sequence is actually a
9288 function key's escape sequence, we replace the suffix with the
9289 function key's binding from Vfunction_key_map. Now keybuf
9290 contains a new and different key sequence, so the echo area,
9291 this_command_keys, and the submaps and defs arrays are wrong. In
9292 this situation, we set mock_input to t, set t to 0, and jump to
9293 restart_sequence; the loop will read keys from keybuf up until
9294 mock_input, thus rebuilding the state; and then it will resume
9295 reading characters from the keyboard. */
9296 int mock_input = 0;
9298 /* If the sequence is unbound in submaps[], then
9299 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9300 and fkey.map is its binding.
9302 These might be > t, indicating that all function key scanning
9303 should hold off until t reaches them. We do this when we've just
9304 recognized a function key, to avoid searching for the function
9305 key's again in Vfunction_key_map. */
9306 keyremap fkey;
9308 /* Likewise, for key_translation_map and input-decode-map. */
9309 keyremap keytran, indec;
9311 /* Non-zero if we are trying to map a key by changing an upper-case
9312 letter to lower case, or a shifted function key to an unshifted
9313 one. */
9314 int shift_translated = 0;
9316 /* If we receive a `switch-frame' or `select-window' event in the middle of
9317 a key sequence, we put it off for later.
9318 While we're reading, we keep the event here. */
9319 Lisp_Object delayed_switch_frame;
9321 /* See the comment below... */
9322 #if defined (GOBBLE_FIRST_EVENT)
9323 Lisp_Object first_event;
9324 #endif
9326 Lisp_Object original_uppercase;
9327 int original_uppercase_position = -1;
9329 /* Gets around Microsoft compiler limitations. */
9330 int dummyflag = 0;
9332 struct buffer *starting_buffer;
9334 /* List of events for which a fake prefix key has been generated. */
9335 Lisp_Object fake_prefixed_keys = Qnil;
9337 #if defined (GOBBLE_FIRST_EVENT)
9338 int junk;
9339 #endif
9341 struct gcpro gcpro1;
9343 GCPRO1 (fake_prefixed_keys);
9344 raw_keybuf_count = 0;
9346 last_nonmenu_event = Qnil;
9348 delayed_switch_frame = Qnil;
9350 if (INTERACTIVE)
9352 if (!NILP (prompt))
9353 echo_prompt (prompt);
9354 else if (cursor_in_echo_area
9355 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
9356 && NILP (Fzerop (Vecho_keystrokes)))
9357 /* This doesn't put in a dash if the echo buffer is empty, so
9358 you don't always see a dash hanging out in the minibuffer. */
9359 echo_dash ();
9362 /* Record the initial state of the echo area and this_command_keys;
9363 we will need to restore them if we replay a key sequence. */
9364 if (INTERACTIVE)
9365 echo_start = echo_length ();
9366 keys_start = this_command_key_count;
9367 this_single_command_key_start = keys_start;
9369 #if defined (GOBBLE_FIRST_EVENT)
9370 /* This doesn't quite work, because some of the things that read_char
9371 does cannot safely be bypassed. It seems too risky to try to make
9372 this work right. */
9374 /* Read the first char of the sequence specially, before setting
9375 up any keymaps, in case a filter runs and switches buffers on us. */
9376 first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
9377 &junk, NULL);
9378 #endif /* GOBBLE_FIRST_EVENT */
9380 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
9381 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
9382 from_string = Qnil;
9384 /* We jump here when we need to reinitialize fkey and keytran; this
9385 happens if we switch keyboards between rescans. */
9386 replay_entire_sequence:
9388 indec.map = indec.parent = current_kboard->Vinput_decode_map;
9389 fkey.map = fkey.parent = current_kboard->Vlocal_function_key_map;
9390 keytran.map = keytran.parent = Vkey_translation_map;
9391 indec.start = indec.end = 0;
9392 fkey.start = fkey.end = 0;
9393 keytran.start = keytran.end = 0;
9395 /* We jump here when the key sequence has been thoroughly changed, and
9396 we need to rescan it starting from the beginning. When we jump here,
9397 keybuf[0..mock_input] holds the sequence we should reread. */
9398 replay_sequence:
9400 starting_buffer = current_buffer;
9401 first_unbound = bufsize + 1;
9403 /* Build our list of keymaps.
9404 If we recognize a function key and replace its escape sequence in
9405 keybuf with its symbol, or if the sequence starts with a mouse
9406 click and we need to switch buffers, we jump back here to rebuild
9407 the initial keymaps from the current buffer. */
9408 nmaps = 0;
9410 if (!NILP (current_kboard->Voverriding_terminal_local_map))
9412 if (2 > nmaps_allocated)
9414 submaps = (Lisp_Object *) alloca (2 * sizeof (submaps[0]));
9415 defs = (Lisp_Object *) alloca (2 * sizeof (defs[0]));
9416 nmaps_allocated = 2;
9418 submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
9420 else if (!NILP (Voverriding_local_map))
9422 if (2 > nmaps_allocated)
9424 submaps = (Lisp_Object *) alloca (2 * sizeof (submaps[0]));
9425 defs = (Lisp_Object *) alloca (2 * sizeof (defs[0]));
9426 nmaps_allocated = 2;
9428 submaps[nmaps++] = Voverriding_local_map;
9430 else
9432 int nminor;
9433 int total;
9434 Lisp_Object *maps;
9436 nminor = current_minor_maps (0, &maps);
9437 total = nminor + (!NILP (orig_keymap) ? 3 : 2);
9439 if (total > nmaps_allocated)
9441 submaps = (Lisp_Object *) alloca (total * sizeof (submaps[0]));
9442 defs = (Lisp_Object *) alloca (total * sizeof (defs[0]));
9443 nmaps_allocated = total;
9446 if (!NILP (orig_keymap))
9447 submaps[nmaps++] = orig_keymap;
9449 bcopy (maps, (void *) (submaps + nmaps),
9450 nminor * sizeof (submaps[0]));
9452 nmaps += nminor;
9454 submaps[nmaps++] = orig_local_map;
9456 submaps[nmaps++] = current_global_map;
9458 /* Find an accurate initial value for first_binding. */
9459 for (first_binding = 0; first_binding < nmaps; first_binding++)
9460 if (! NILP (submaps[first_binding]))
9461 break;
9463 /* Start from the beginning in keybuf. */
9464 t = 0;
9466 /* These are no-ops the first time through, but if we restart, they
9467 revert the echo area and this_command_keys to their original state. */
9468 this_command_key_count = keys_start;
9469 if (INTERACTIVE && t < mock_input)
9470 echo_truncate (echo_start);
9472 /* If the best binding for the current key sequence is a keymap, or
9473 we may be looking at a function key's escape sequence, keep on
9474 reading. */
9475 while (first_binding < nmaps
9476 /* Keep reading as long as there's a prefix binding. */
9477 ? !NILP (submaps[first_binding])
9478 /* Don't return in the middle of a possible function key sequence,
9479 if the only bindings we found were via case conversion.
9480 Thus, if ESC O a has a function-key-map translation
9481 and ESC o has a binding, don't return after ESC O,
9482 so that we can translate ESC O plus the next character. */
9483 : (/* indec.start < t || fkey.start < t || */ keytran.start < t))
9485 Lisp_Object key;
9486 int used_mouse_menu = 0;
9488 /* Where the last real key started. If we need to throw away a
9489 key that has expanded into more than one element of keybuf
9490 (say, a mouse click on the mode line which is being treated
9491 as [mode-line (mouse-...)], then we backtrack to this point
9492 of keybuf. */
9493 int last_real_key_start;
9495 /* These variables are analogous to echo_start and keys_start;
9496 while those allow us to restart the entire key sequence,
9497 echo_local_start and keys_local_start allow us to throw away
9498 just one key. */
9499 int echo_local_start, keys_local_start, local_first_binding;
9501 eassert (indec.end == t || (indec.end > t && indec.end <= mock_input));
9502 eassert (indec.start <= indec.end);
9503 eassert (fkey.start <= fkey.end);
9504 eassert (keytran.start <= keytran.end);
9505 /* key-translation-map is applied *after* function-key-map
9506 which is itself applied *after* input-decode-map. */
9507 eassert (fkey.end <= indec.start);
9508 eassert (keytran.end <= fkey.start);
9510 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9511 first_unbound < keytran.start)
9512 { /* The prefix upto first_unbound has no binding and has
9513 no translation left to do either, so we know it's unbound.
9514 If we don't stop now, we risk staying here indefinitely
9515 (if the user keeps entering fkey or keytran prefixes
9516 like C-c ESC ESC ESC ESC ...) */
9517 int i;
9518 for (i = first_unbound + 1; i < t; i++)
9519 keybuf[i - first_unbound - 1] = keybuf[i];
9520 mock_input = t - first_unbound - 1;
9521 indec.end = indec.start -= first_unbound + 1;
9522 indec.map = indec.parent;
9523 fkey.end = fkey.start -= first_unbound + 1;
9524 fkey.map = fkey.parent;
9525 keytran.end = keytran.start -= first_unbound + 1;
9526 keytran.map = keytran.parent;
9527 goto replay_sequence;
9530 if (t >= bufsize)
9531 error ("Key sequence too long");
9533 if (INTERACTIVE)
9534 echo_local_start = echo_length ();
9535 keys_local_start = this_command_key_count;
9536 local_first_binding = first_binding;
9538 replay_key:
9539 /* These are no-ops, unless we throw away a keystroke below and
9540 jumped back up to replay_key; in that case, these restore the
9541 variables to their original state, allowing us to replay the
9542 loop. */
9543 if (INTERACTIVE && t < mock_input)
9544 echo_truncate (echo_local_start);
9545 this_command_key_count = keys_local_start;
9546 first_binding = local_first_binding;
9548 /* By default, assume each event is "real". */
9549 last_real_key_start = t;
9551 /* Does mock_input indicate that we are re-reading a key sequence? */
9552 if (t < mock_input)
9554 key = keybuf[t];
9555 add_command_key (key);
9556 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
9557 && NILP (Fzerop (Vecho_keystrokes)))
9558 echo_char (key);
9561 /* If not, we should actually read a character. */
9562 else
9565 KBOARD *interrupted_kboard = current_kboard;
9566 struct frame *interrupted_frame = SELECTED_FRAME ();
9567 key = read_char (NILP (prompt), nmaps,
9568 (Lisp_Object *) submaps, last_nonmenu_event,
9569 &used_mouse_menu, NULL);
9570 if ((INTEGERP (key) && XINT (key) == -2) /* wrong_kboard_jmpbuf */
9571 /* When switching to a new tty (with a new keyboard),
9572 read_char returns the new buffer, rather than -2
9573 (Bug#5095). This is because `terminal-init-xterm'
9574 calls read-char, which eats the wrong_kboard_jmpbuf
9575 return. Any better way to fix this? -- cyd */
9576 || (interrupted_kboard != current_kboard))
9578 int found = 0;
9579 struct kboard *k;
9581 for (k = all_kboards; k; k = k->next_kboard)
9582 if (k == interrupted_kboard)
9583 found = 1;
9585 if (!found)
9587 /* Don't touch interrupted_kboard when it's been
9588 deleted. */
9589 delayed_switch_frame = Qnil;
9590 goto replay_entire_sequence;
9593 if (!NILP (delayed_switch_frame))
9595 interrupted_kboard->kbd_queue
9596 = Fcons (delayed_switch_frame,
9597 interrupted_kboard->kbd_queue);
9598 delayed_switch_frame = Qnil;
9601 while (t > 0)
9602 interrupted_kboard->kbd_queue
9603 = Fcons (keybuf[--t], interrupted_kboard->kbd_queue);
9605 /* If the side queue is non-empty, ensure it begins with a
9606 switch-frame, so we'll replay it in the right context. */
9607 if (CONSP (interrupted_kboard->kbd_queue)
9608 && (key = XCAR (interrupted_kboard->kbd_queue),
9609 !(EVENT_HAS_PARAMETERS (key)
9610 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)),
9611 Qswitch_frame))))
9613 Lisp_Object frame;
9614 XSETFRAME (frame, interrupted_frame);
9615 interrupted_kboard->kbd_queue
9616 = Fcons (make_lispy_switch_frame (frame),
9617 interrupted_kboard->kbd_queue);
9619 mock_input = 0;
9620 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
9621 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
9622 goto replay_entire_sequence;
9626 /* read_char returns t when it shows a menu and the user rejects it.
9627 Just return -1. */
9628 if (EQ (key, Qt))
9630 unbind_to (count, Qnil);
9631 UNGCPRO;
9632 return -1;
9635 /* read_char returns -1 at the end of a macro.
9636 Emacs 18 handles this by returning immediately with a
9637 zero, so that's what we'll do. */
9638 if (INTEGERP (key) && XINT (key) == -1)
9640 t = 0;
9641 /* The Microsoft C compiler can't handle the goto that
9642 would go here. */
9643 dummyflag = 1;
9644 break;
9647 /* If the current buffer has been changed from under us, the
9648 keymap may have changed, so replay the sequence. */
9649 if (BUFFERP (key))
9651 timer_resume_idle ();
9653 mock_input = t;
9654 /* Reset the current buffer from the selected window
9655 in case something changed the former and not the latter.
9656 This is to be more consistent with the behavior
9657 of the command_loop_1. */
9658 if (fix_current_buffer)
9660 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
9661 Fkill_emacs (Qnil);
9662 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
9663 Fset_buffer (XWINDOW (selected_window)->buffer);
9666 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
9667 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
9668 goto replay_sequence;
9671 /* If we have a quit that was typed in another frame, and
9672 quit_throw_to_read_char switched buffers,
9673 replay to get the right keymap. */
9674 if (INTEGERP (key)
9675 && XINT (key) == quit_char
9676 && current_buffer != starting_buffer)
9678 GROW_RAW_KEYBUF;
9679 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
9680 keybuf[t++] = key;
9681 mock_input = t;
9682 Vquit_flag = Qnil;
9683 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
9684 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
9685 goto replay_sequence;
9688 Vquit_flag = Qnil;
9690 if (EVENT_HAS_PARAMETERS (key)
9691 /* Either a `switch-frame' or a `select-window' event. */
9692 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)), Qswitch_frame))
9694 /* If we're at the beginning of a key sequence, and the caller
9695 says it's okay, go ahead and return this event. If we're
9696 in the midst of a key sequence, delay it until the end. */
9697 if (t > 0 || !can_return_switch_frame)
9699 delayed_switch_frame = key;
9700 goto replay_key;
9704 GROW_RAW_KEYBUF;
9705 ASET (raw_keybuf, raw_keybuf_count, key);
9706 raw_keybuf_count++;
9709 /* Clicks in non-text areas get prefixed by the symbol
9710 in their CHAR-ADDRESS field. For example, a click on
9711 the mode line is prefixed by the symbol `mode-line'.
9713 Furthermore, key sequences beginning with mouse clicks
9714 are read using the keymaps of the buffer clicked on, not
9715 the current buffer. So we may have to switch the buffer
9716 here.
9718 When we turn one event into two events, we must make sure
9719 that neither of the two looks like the original--so that,
9720 if we replay the events, they won't be expanded again.
9721 If not for this, such reexpansion could happen either here
9722 or when user programs play with this-command-keys. */
9723 if (EVENT_HAS_PARAMETERS (key))
9725 Lisp_Object kind;
9726 Lisp_Object string;
9728 kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
9729 if (EQ (kind, Qmouse_click))
9731 Lisp_Object window, posn;
9733 window = POSN_WINDOW (EVENT_START (key));
9734 posn = POSN_POSN (EVENT_START (key));
9736 if (CONSP (posn)
9737 || (!NILP (fake_prefixed_keys)
9738 && !NILP (Fmemq (key, fake_prefixed_keys))))
9740 /* We're looking a second time at an event for which
9741 we generated a fake prefix key. Set
9742 last_real_key_start appropriately. */
9743 if (t > 0)
9744 last_real_key_start = t - 1;
9747 /* Key sequences beginning with mouse clicks are
9748 read using the keymaps in the buffer clicked on,
9749 not the current buffer. If we're at the
9750 beginning of a key sequence, switch buffers. */
9751 if (last_real_key_start == 0
9752 && WINDOWP (window)
9753 && BUFFERP (XWINDOW (window)->buffer)
9754 && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
9756 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
9757 keybuf[t] = key;
9758 mock_input = t + 1;
9760 /* Arrange to go back to the original buffer once we're
9761 done reading the key sequence. Note that we can't
9762 use save_excursion_{save,restore} here, because they
9763 save point as well as the current buffer; we don't
9764 want to save point, because redisplay may change it,
9765 to accommodate a Fset_window_start or something. We
9766 don't want to do this at the top of the function,
9767 because we may get input from a subprocess which
9768 wants to change the selected window and stuff (say,
9769 emacsclient). */
9770 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
9772 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
9773 Fkill_emacs (Qnil);
9774 set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
9775 orig_local_map = get_local_map (PT, current_buffer,
9776 Qlocal_map);
9777 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
9778 goto replay_sequence;
9781 /* For a mouse click, get the local text-property keymap
9782 of the place clicked on, rather than point. */
9783 if (last_real_key_start == 0
9784 && CONSP (XCDR (key))
9785 && ! localized_local_map)
9787 Lisp_Object map_here, start, pos;
9789 localized_local_map = 1;
9790 start = EVENT_START (key);
9792 if (CONSP (start) && POSN_INBUFFER_P (start))
9794 pos = POSN_BUFFER_POSN (start);
9795 if (INTEGERP (pos)
9796 && XINT (pos) >= BEGV
9797 && XINT (pos) <= ZV)
9799 map_here = get_local_map (XINT (pos),
9800 current_buffer, Qlocal_map);
9801 if (!EQ (map_here, orig_local_map))
9803 orig_local_map = map_here;
9804 ++localized_local_map;
9807 map_here = get_local_map (XINT (pos),
9808 current_buffer, Qkeymap);
9809 if (!EQ (map_here, orig_keymap))
9811 orig_keymap = map_here;
9812 ++localized_local_map;
9815 if (localized_local_map > 1)
9817 keybuf[t] = key;
9818 mock_input = t + 1;
9820 goto replay_sequence;
9826 /* Expand mode-line and scroll-bar events into two events:
9827 use posn as a fake prefix key. */
9828 if (SYMBOLP (posn)
9829 && (NILP (fake_prefixed_keys)
9830 || NILP (Fmemq (key, fake_prefixed_keys))))
9832 if (t + 1 >= bufsize)
9833 error ("Key sequence too long");
9835 keybuf[t] = posn;
9836 keybuf[t + 1] = key;
9837 mock_input = t + 2;
9839 /* Record that a fake prefix key has been generated
9840 for KEY. Don't modify the event; this would
9841 prevent proper action when the event is pushed
9842 back into unread-command-events. */
9843 fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
9845 /* If on a mode line string with a local keymap,
9846 reconsider the key sequence with that keymap. */
9847 if (string = POSN_STRING (EVENT_START (key)),
9848 (CONSP (string) && STRINGP (XCAR (string))))
9850 Lisp_Object pos, map, map2;
9852 pos = XCDR (string);
9853 string = XCAR (string);
9854 if (XINT (pos) >= 0
9855 && XINT (pos) < SCHARS (string))
9857 map = Fget_text_property (pos, Qlocal_map, string);
9858 if (!NILP (map))
9859 orig_local_map = map;
9860 map2 = Fget_text_property (pos, Qkeymap, string);
9861 if (!NILP (map2))
9862 orig_keymap = map2;
9863 if (!NILP (map) || !NILP (map2))
9864 goto replay_sequence;
9868 goto replay_key;
9870 else if (NILP (from_string)
9871 && (string = POSN_STRING (EVENT_START (key)),
9872 (CONSP (string) && STRINGP (XCAR (string)))))
9874 /* For a click on a string, i.e. overlay string or a
9875 string displayed via the `display' property,
9876 consider `local-map' and `keymap' properties of
9877 that string. */
9878 Lisp_Object pos, map, map2;
9880 pos = XCDR (string);
9881 string = XCAR (string);
9882 if (XINT (pos) >= 0
9883 && XINT (pos) < SCHARS (string))
9885 map = Fget_text_property (pos, Qlocal_map, string);
9886 if (!NILP (map))
9887 orig_local_map = map;
9888 map2 = Fget_text_property (pos, Qkeymap, string);
9889 if (!NILP (map2))
9890 orig_keymap = map2;
9892 if (!NILP (map) || !NILP (map2))
9894 from_string = string;
9895 keybuf[t++] = key;
9896 mock_input = t;
9897 goto replay_sequence;
9902 else if (CONSP (XCDR (key))
9903 && CONSP (EVENT_START (key))
9904 && CONSP (XCDR (EVENT_START (key))))
9906 Lisp_Object posn;
9908 posn = POSN_POSN (EVENT_START (key));
9909 /* Handle menu-bar events:
9910 insert the dummy prefix event `menu-bar'. */
9911 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
9913 if (t + 1 >= bufsize)
9914 error ("Key sequence too long");
9915 keybuf[t] = posn;
9916 keybuf[t+1] = key;
9918 /* Zap the position in key, so we know that we've
9919 expanded it, and don't try to do so again. */
9920 POSN_SET_POSN (EVENT_START (key),
9921 Fcons (posn, Qnil));
9923 mock_input = t + 2;
9924 goto replay_sequence;
9926 else if (CONSP (posn))
9928 /* We're looking at the second event of a
9929 sequence which we expanded before. Set
9930 last_real_key_start appropriately. */
9931 if (last_real_key_start == t && t > 0)
9932 last_real_key_start = t - 1;
9937 /* We have finally decided that KEY is something we might want
9938 to look up. */
9939 first_binding = (follow_key (key,
9940 nmaps - first_binding,
9941 submaps + first_binding,
9942 defs + first_binding,
9943 submaps + first_binding)
9944 + first_binding);
9946 /* If KEY wasn't bound, we'll try some fallbacks. */
9947 if (first_binding < nmaps)
9948 /* This is needed for the following scenario:
9949 event 0: a down-event that gets dropped by calling replay_key.
9950 event 1: some normal prefix like C-h.
9951 After event 0, first_unbound is 0, after event 1 indec.start,
9952 fkey.start, and keytran.start are all 1, so when we see that
9953 C-h is bound, we need to update first_unbound. */
9954 first_unbound = max (t + 1, first_unbound);
9955 else
9957 Lisp_Object head;
9959 /* Remember the position to put an upper bound on indec.start. */
9960 first_unbound = min (t, first_unbound);
9962 head = EVENT_HEAD (key);
9963 if (help_char_p (head) && t > 0)
9965 read_key_sequence_cmd = Vprefix_help_command;
9966 keybuf[t++] = key;
9967 last_nonmenu_event = key;
9968 /* The Microsoft C compiler can't handle the goto that
9969 would go here. */
9970 dummyflag = 1;
9971 break;
9974 if (SYMBOLP (head))
9976 Lisp_Object breakdown;
9977 int modifiers;
9979 breakdown = parse_modifiers (head);
9980 modifiers = XINT (XCAR (XCDR (breakdown)));
9981 /* Attempt to reduce an unbound mouse event to a simpler
9982 event that is bound:
9983 Drags reduce to clicks.
9984 Double-clicks reduce to clicks.
9985 Triple-clicks reduce to double-clicks, then to clicks.
9986 Down-clicks are eliminated.
9987 Double-downs reduce to downs, then are eliminated.
9988 Triple-downs reduce to double-downs, then to downs,
9989 then are eliminated. */
9990 if (modifiers & (down_modifier | drag_modifier
9991 | double_modifier | triple_modifier))
9993 while (modifiers & (down_modifier | drag_modifier
9994 | double_modifier | triple_modifier))
9996 Lisp_Object new_head, new_click;
9997 if (modifiers & triple_modifier)
9998 modifiers ^= (double_modifier | triple_modifier);
9999 else if (modifiers & double_modifier)
10000 modifiers &= ~double_modifier;
10001 else if (modifiers & drag_modifier)
10002 modifiers &= ~drag_modifier;
10003 else
10005 /* Dispose of this `down' event by simply jumping
10006 back to replay_key, to get another event.
10008 Note that if this event came from mock input,
10009 then just jumping back to replay_key will just
10010 hand it to us again. So we have to wipe out any
10011 mock input.
10013 We could delete keybuf[t] and shift everything
10014 after that to the left by one spot, but we'd also
10015 have to fix up any variable that points into
10016 keybuf, and shifting isn't really necessary
10017 anyway.
10019 Adding prefixes for non-textual mouse clicks
10020 creates two characters of mock input, and both
10021 must be thrown away. If we're only looking at
10022 the prefix now, we can just jump back to
10023 replay_key. On the other hand, if we've already
10024 processed the prefix, and now the actual click
10025 itself is giving us trouble, then we've lost the
10026 state of the keymaps we want to backtrack to, and
10027 we need to replay the whole sequence to rebuild
10030 Beyond that, only function key expansion could
10031 create more than two keys, but that should never
10032 generate mouse events, so it's okay to zero
10033 mock_input in that case too.
10035 FIXME: The above paragraph seems just plain
10036 wrong, if you consider things like
10037 xterm-mouse-mode. -stef
10039 Isn't this just the most wonderful code ever? */
10041 /* If mock_input > t + 1, the above simplification
10042 will actually end up dropping keys on the floor.
10043 This is probably OK for now, but even
10044 if mock_input <= t + 1, we need to adjust indec,
10045 fkey, and keytran.
10046 Typical case [header-line down-mouse-N]:
10047 mock_input = 2, t = 1, fkey.end = 1,
10048 last_real_key_start = 0. */
10049 if (indec.end > last_real_key_start)
10051 indec.end = indec.start
10052 = min (last_real_key_start, indec.start);
10053 indec.map = indec.parent;
10054 if (fkey.end > last_real_key_start)
10056 fkey.end = fkey.start
10057 = min (last_real_key_start, fkey.start);
10058 fkey.map = fkey.parent;
10059 if (keytran.end > last_real_key_start)
10061 keytran.end = keytran.start
10062 = min (last_real_key_start, keytran.start);
10063 keytran.map = keytran.parent;
10067 if (t == last_real_key_start)
10069 mock_input = 0;
10070 goto replay_key;
10072 else
10074 mock_input = last_real_key_start;
10075 goto replay_sequence;
10079 new_head
10080 = apply_modifiers (modifiers, XCAR (breakdown));
10081 new_click
10082 = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
10084 /* Look for a binding for this new key. follow_key
10085 promises that it didn't munge submaps the
10086 last time we called it, since key was unbound. */
10087 first_binding
10088 = (follow_key (new_click,
10089 nmaps - local_first_binding,
10090 submaps + local_first_binding,
10091 defs + local_first_binding,
10092 submaps + local_first_binding)
10093 + local_first_binding);
10095 /* If that click is bound, go for it. */
10096 if (first_binding < nmaps)
10098 key = new_click;
10099 break;
10101 /* Otherwise, we'll leave key set to the drag event. */
10107 keybuf[t++] = key;
10108 /* Normally, last_nonmenu_event gets the previous key we read.
10109 But when a mouse popup menu is being used,
10110 we don't update last_nonmenu_event; it continues to hold the mouse
10111 event that preceded the first level of menu. */
10112 if (!used_mouse_menu)
10113 last_nonmenu_event = key;
10115 /* Record what part of this_command_keys is the current key sequence. */
10116 this_single_command_key_start = this_command_key_count - t;
10118 /* Look for this sequence in input-decode-map.
10119 Scan from indec.end until we find a bound suffix. */
10120 while (indec.end < t)
10122 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
10123 int done, diff;
10125 GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
10126 done = keyremap_step (keybuf, bufsize, &indec, max (t, mock_input),
10127 1, &diff, prompt);
10128 UNGCPRO;
10129 if (done)
10131 mock_input = diff + max (t, mock_input);
10132 goto replay_sequence;
10136 if (first_binding < nmaps && NILP (submaps[first_binding])
10137 && indec.start >= t)
10138 /* There is a binding and it's not a prefix.
10139 (and it doesn't have any input-decode-map translation pending).
10140 There is thus no function-key in this sequence.
10141 Moving fkey.start is important in this case to allow keytran.start
10142 to go over the sequence before we return (since we keep the
10143 invariant that keytran.end <= fkey.start). */
10145 if (fkey.start < t)
10146 (fkey.start = fkey.end = t, fkey.map = fkey.parent);
10148 else
10149 /* If the sequence is unbound, see if we can hang a function key
10150 off the end of it. */
10151 /* Continue scan from fkey.end until we find a bound suffix. */
10152 while (fkey.end < indec.start)
10154 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
10155 int done, diff;
10157 GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
10158 done = keyremap_step (keybuf, bufsize, &fkey,
10159 max (t, mock_input),
10160 /* If there's a binding (i.e.
10161 first_binding >= nmaps) we don't want
10162 to apply this function-key-mapping. */
10163 fkey.end + 1 == t && first_binding >= nmaps,
10164 &diff, prompt);
10165 UNGCPRO;
10166 if (done)
10168 mock_input = diff + max (t, mock_input);
10169 /* Adjust the input-decode-map counters. */
10170 indec.end += diff;
10171 indec.start += diff;
10173 goto replay_sequence;
10177 /* Look for this sequence in key-translation-map.
10178 Scan from keytran.end until we find a bound suffix. */
10179 while (keytran.end < fkey.start)
10181 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
10182 int done, diff;
10184 GCPRO4 (indec.map, fkey.map, keytran.map, delayed_switch_frame);
10185 done = keyremap_step (keybuf, bufsize, &keytran, max (t, mock_input),
10186 1, &diff, prompt);
10187 UNGCPRO;
10188 if (done)
10190 mock_input = diff + max (t, mock_input);
10191 /* Adjust the function-key-map and input-decode-map counters. */
10192 indec.end += diff;
10193 indec.start += diff;
10194 fkey.end += diff;
10195 fkey.start += diff;
10197 goto replay_sequence;
10201 /* If KEY is not defined in any of the keymaps,
10202 and cannot be part of a function key or translation,
10203 and is an upper case letter
10204 use the corresponding lower-case letter instead. */
10205 if (first_binding >= nmaps
10206 && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
10207 && INTEGERP (key)
10208 && ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
10209 && UPPERCASEP (XINT (key) & ~CHAR_MODIFIER_MASK))
10210 || (XINT (key) & shift_modifier)))
10212 Lisp_Object new_key;
10214 original_uppercase = key;
10215 original_uppercase_position = t - 1;
10217 if (XINT (key) & shift_modifier)
10218 XSETINT (new_key, XINT (key) & ~shift_modifier);
10219 else
10220 XSETINT (new_key, (DOWNCASE (XINT (key) & ~CHAR_MODIFIER_MASK)
10221 | (XINT (key) & CHAR_MODIFIER_MASK)));
10223 /* We have to do this unconditionally, regardless of whether
10224 the lower-case char is defined in the keymaps, because they
10225 might get translated through function-key-map. */
10226 keybuf[t - 1] = new_key;
10227 mock_input = max (t, mock_input);
10228 shift_translated = 1;
10230 goto replay_sequence;
10232 /* If KEY is not defined in any of the keymaps,
10233 and cannot be part of a function key or translation,
10234 and is a shifted function key,
10235 use the corresponding unshifted function key instead. */
10236 if (first_binding >= nmaps
10237 && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t)
10239 Lisp_Object breakdown = parse_modifiers (key);
10240 int modifiers
10241 = CONSP (breakdown) ? (XINT (XCAR (XCDR (breakdown)))) : 0;
10243 if (modifiers & shift_modifier
10244 /* Treat uppercase keys as shifted. */
10245 || (INTEGERP (key)
10246 && (KEY_TO_CHAR (key)
10247 < XCHAR_TABLE (current_buffer->downcase_table)->size)
10248 && UPPERCASEP (KEY_TO_CHAR (key))))
10250 Lisp_Object new_key
10251 = (modifiers & shift_modifier
10252 ? apply_modifiers (modifiers & ~shift_modifier,
10253 XCAR (breakdown))
10254 : make_number (DOWNCASE (KEY_TO_CHAR (key)) | modifiers));
10256 original_uppercase = key;
10257 original_uppercase_position = t - 1;
10259 /* We have to do this unconditionally, regardless of whether
10260 the lower-case char is defined in the keymaps, because they
10261 might get translated through function-key-map. */
10262 keybuf[t - 1] = new_key;
10263 mock_input = max (t, mock_input);
10264 /* Reset fkey (and consequently keytran) to apply
10265 function-key-map on the result, so that S-backspace is
10266 correctly mapped to DEL (via backspace). OTOH,
10267 input-decode-map doesn't need to go through it again. */
10268 fkey.start = fkey.end = 0;
10269 keytran.start = keytran.end = 0;
10270 shift_translated = 1;
10272 goto replay_sequence;
10276 if (!dummyflag)
10277 read_key_sequence_cmd = (first_binding < nmaps
10278 ? defs[first_binding]
10279 : Qnil);
10281 unread_switch_frame = delayed_switch_frame;
10282 unbind_to (count, Qnil);
10284 /* Don't downcase the last character if the caller says don't.
10285 Don't downcase it if the result is undefined, either. */
10286 if ((dont_downcase_last || first_binding >= nmaps)
10287 && t > 0
10288 && t - 1 == original_uppercase_position)
10290 keybuf[t - 1] = original_uppercase;
10291 shift_translated = 0;
10294 if (shift_translated)
10295 Vthis_command_keys_shift_translated = Qt;
10297 /* Occasionally we fabricate events, perhaps by expanding something
10298 according to function-key-map, or by adding a prefix symbol to a
10299 mouse click in the scroll bar or modeline. In this cases, return
10300 the entire generated key sequence, even if we hit an unbound
10301 prefix or a definition before the end. This means that you will
10302 be able to push back the event properly, and also means that
10303 read-key-sequence will always return a logical unit.
10305 Better ideas? */
10306 for (; t < mock_input; t++)
10308 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
10309 && NILP (Fzerop (Vecho_keystrokes)))
10310 echo_char (keybuf[t]);
10311 add_command_key (keybuf[t]);
10314 UNGCPRO;
10315 return t;
10318 DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 5, 0,
10319 doc: /* Read a sequence of keystrokes and return as a string or vector.
10320 The sequence is sufficient to specify a non-prefix command in the
10321 current local and global maps.
10323 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10324 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10325 as a continuation of the previous key.
10327 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10328 convert the last event to lower case. (Normally any upper case event
10329 is converted to lower case if the original event is undefined and the lower
10330 case equivalent is defined.) A non-nil value is appropriate for reading
10331 a key sequence to be defined.
10333 A C-g typed while in this function is treated like any other character,
10334 and `quit-flag' is not set.
10336 If the key sequence starts with a mouse click, then the sequence is read
10337 using the keymaps of the buffer of the window clicked in, not the buffer
10338 of the selected window as normal.
10340 `read-key-sequence' drops unbound button-down events, since you normally
10341 only care about the click or drag events which follow them. If a drag
10342 or multi-click event is unbound, but the corresponding click event would
10343 be bound, `read-key-sequence' turns the event into a click event at the
10344 drag's starting position. This means that you don't have to distinguish
10345 between click and drag, double, or triple events unless you want to.
10347 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10348 lines separating windows, and scroll bars with imaginary keys
10349 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10351 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10352 function will process a switch-frame event if the user switches frames
10353 before typing anything. If the user switches frames in the middle of a
10354 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10355 is nil, then the event will be put off until after the current key sequence.
10357 `read-key-sequence' checks `function-key-map' for function key
10358 sequences, where they wouldn't conflict with ordinary bindings. See
10359 `function-key-map' for more details.
10361 The optional fifth argument COMMAND-LOOP, if non-nil, means
10362 that this key sequence is being read by something that will
10363 read commands one after another. It should be nil if the caller
10364 will read just one key sequence. */)
10365 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
10366 command_loop)
10367 Lisp_Object prompt, continue_echo, dont_downcase_last;
10368 Lisp_Object can_return_switch_frame, command_loop;
10370 Lisp_Object keybuf[30];
10371 register int i;
10372 struct gcpro gcpro1;
10373 int count = SPECPDL_INDEX ();
10375 if (!NILP (prompt))
10376 CHECK_STRING (prompt);
10377 QUIT;
10379 specbind (Qinput_method_exit_on_first_char,
10380 (NILP (command_loop) ? Qt : Qnil));
10381 specbind (Qinput_method_use_echo_area,
10382 (NILP (command_loop) ? Qt : Qnil));
10384 bzero (keybuf, sizeof keybuf);
10385 GCPRO1 (keybuf[0]);
10386 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
10388 if (NILP (continue_echo))
10390 this_command_key_count = 0;
10391 this_command_key_count_reset = 0;
10392 this_single_command_key_start = 0;
10395 #ifdef HAVE_WINDOW_SYSTEM
10396 if (display_hourglass_p)
10397 cancel_hourglass ();
10398 #endif
10400 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
10401 prompt, ! NILP (dont_downcase_last),
10402 ! NILP (can_return_switch_frame), 0);
10404 #if 0 /* The following is fine for code reading a key sequence and
10405 then proceeding with a lenghty computation, but it's not good
10406 for code reading keys in a loop, like an input method. */
10407 #ifdef HAVE_WINDOW_SYSTEM
10408 if (display_hourglass_p)
10409 start_hourglass ();
10410 #endif
10411 #endif
10413 if (i == -1)
10415 Vquit_flag = Qt;
10416 QUIT;
10418 UNGCPRO;
10419 return unbind_to (count, make_event_array (i, keybuf));
10422 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
10423 Sread_key_sequence_vector, 1, 5, 0,
10424 doc: /* Like `read-key-sequence' but always return a vector. */)
10425 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
10426 command_loop)
10427 Lisp_Object prompt, continue_echo, dont_downcase_last;
10428 Lisp_Object can_return_switch_frame, command_loop;
10430 Lisp_Object keybuf[30];
10431 register int i;
10432 struct gcpro gcpro1;
10433 int count = SPECPDL_INDEX ();
10435 if (!NILP (prompt))
10436 CHECK_STRING (prompt);
10437 QUIT;
10439 specbind (Qinput_method_exit_on_first_char,
10440 (NILP (command_loop) ? Qt : Qnil));
10441 specbind (Qinput_method_use_echo_area,
10442 (NILP (command_loop) ? Qt : Qnil));
10444 bzero (keybuf, sizeof keybuf);
10445 GCPRO1 (keybuf[0]);
10446 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
10448 if (NILP (continue_echo))
10450 this_command_key_count = 0;
10451 this_command_key_count_reset = 0;
10452 this_single_command_key_start = 0;
10455 #ifdef HAVE_WINDOW_SYSTEM
10456 if (display_hourglass_p)
10457 cancel_hourglass ();
10458 #endif
10460 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
10461 prompt, ! NILP (dont_downcase_last),
10462 ! NILP (can_return_switch_frame), 0);
10464 #ifdef HAVE_WINDOW_SYSTEM
10465 if (display_hourglass_p)
10466 start_hourglass ();
10467 #endif
10469 if (i == -1)
10471 Vquit_flag = Qt;
10472 QUIT;
10474 UNGCPRO;
10475 return unbind_to (count, Fvector (i, keybuf));
10478 DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
10479 doc: /* Execute CMD as an editor command.
10480 CMD must be a symbol that satisfies the `commandp' predicate.
10481 Optional second arg RECORD-FLAG non-nil
10482 means unconditionally put this command in `command-history'.
10483 Otherwise, that is done only if an arg is read using the minibuffer.
10484 The argument KEYS specifies the value to use instead of (this-command-keys)
10485 when reading the arguments; if it is nil, (this-command-keys) is used.
10486 The argument SPECIAL, if non-nil, means that this command is executing
10487 a special event, so ignore the prefix argument and don't clear it. */)
10488 (cmd, record_flag, keys, special)
10489 Lisp_Object cmd, record_flag, keys, special;
10491 register Lisp_Object final;
10492 register Lisp_Object tem;
10493 Lisp_Object prefixarg;
10494 extern int debug_on_next_call;
10496 debug_on_next_call = 0;
10498 if (NILP (special))
10500 prefixarg = current_kboard->Vprefix_arg;
10501 Vcurrent_prefix_arg = prefixarg;
10502 current_kboard->Vprefix_arg = Qnil;
10504 else
10505 prefixarg = Qnil;
10507 if (SYMBOLP (cmd))
10509 tem = Fget (cmd, Qdisabled);
10510 if (!NILP (tem) && !NILP (Vrun_hooks))
10512 tem = Fsymbol_value (Qdisabled_command_function);
10513 if (!NILP (tem))
10514 return call1 (Vrun_hooks, Qdisabled_command_function);
10518 while (1)
10520 final = Findirect_function (cmd, Qnil);
10522 if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
10524 struct gcpro gcpro1, gcpro2;
10526 GCPRO2 (cmd, prefixarg);
10527 do_autoload (final, cmd);
10528 UNGCPRO;
10530 else
10531 break;
10534 if (STRINGP (final) || VECTORP (final))
10536 /* If requested, place the macro in the command history. For
10537 other sorts of commands, call-interactively takes care of
10538 this. */
10539 if (!NILP (record_flag))
10541 Vcommand_history
10542 = Fcons (Fcons (Qexecute_kbd_macro,
10543 Fcons (final, Fcons (prefixarg, Qnil))),
10544 Vcommand_history);
10546 /* Don't keep command history around forever. */
10547 if (NUMBERP (Vhistory_length) && XINT (Vhistory_length) > 0)
10549 tem = Fnthcdr (Vhistory_length, Vcommand_history);
10550 if (CONSP (tem))
10551 XSETCDR (tem, Qnil);
10555 return Fexecute_kbd_macro (final, prefixarg, Qnil);
10558 if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
10559 /* Don't call Fcall_interactively directly because we want to make
10560 sure the backtrace has an entry for `call-interactively'.
10561 For the same reason, pass `cmd' rather than `final'. */
10562 return call3 (Qcall_interactively, cmd, record_flag, keys);
10564 return Qnil;
10569 DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
10570 1, 1, "P",
10571 doc: /* Read function name, then read its arguments and call it.
10573 To pass a numeric argument to the command you are invoking with, specify
10574 the numeric argument to this command.
10576 Noninteractively, the argument PREFIXARG is the prefix argument to
10577 give to the command you invoke, if it asks for an argument. */)
10578 (prefixarg)
10579 Lisp_Object prefixarg;
10581 Lisp_Object function;
10582 char buf[40];
10583 int saved_last_point_position;
10584 Lisp_Object saved_keys, saved_last_point_position_buffer;
10585 Lisp_Object bindings, value;
10586 struct gcpro gcpro1, gcpro2, gcpro3;
10587 #ifdef HAVE_WINDOW_SYSTEM
10588 /* The call to Fcompleting_read wil start and cancel the hourglass,
10589 but if the hourglass was already scheduled, this means that no
10590 hourglass will be shown for the actual M-x command itself.
10591 So we restart it if it is already scheduled. Note that checking
10592 hourglass_shown_p is not enough, normally the hourglass is not shown,
10593 just scheduled to be shown. */
10594 int hstarted = hourglass_started ();
10595 #endif
10597 saved_keys = Fvector (this_command_key_count,
10598 XVECTOR (this_command_keys)->contents);
10599 saved_last_point_position_buffer = last_point_position_buffer;
10600 saved_last_point_position = last_point_position;
10601 buf[0] = 0;
10602 GCPRO3 (saved_keys, prefixarg, saved_last_point_position_buffer);
10604 if (EQ (prefixarg, Qminus))
10605 strcpy (buf, "- ");
10606 else if (CONSP (prefixarg) && XINT (XCAR (prefixarg)) == 4)
10607 strcpy (buf, "C-u ");
10608 else if (CONSP (prefixarg) && INTEGERP (XCAR (prefixarg)))
10609 sprintf (buf, "%ld ", (long) XINT (XCAR (prefixarg)));
10610 else if (INTEGERP (prefixarg))
10611 sprintf (buf, "%ld ", (long) XINT (prefixarg));
10613 /* This isn't strictly correct if execute-extended-command
10614 is bound to anything else. Perhaps it should use
10615 this_command_keys? */
10616 strcat (buf, "M-x ");
10618 /* Prompt with buf, and then read a string, completing from and
10619 restricting to the set of all defined commands. Don't provide
10620 any initial input. Save the command read on the extended-command
10621 history list. */
10622 function = Fcompleting_read (build_string (buf),
10623 Vobarray, Qcommandp,
10624 Qt, Qnil, Qextended_command_history, Qnil,
10625 Qnil);
10627 #ifdef HAVE_WINDOW_SYSTEM
10628 if (hstarted) start_hourglass ();
10629 #endif
10631 if (STRINGP (function) && SCHARS (function) == 0)
10632 error ("No command name given");
10634 /* Set this_command_keys to the concatenation of saved_keys and
10635 function, followed by a RET. */
10637 Lisp_Object *keys;
10638 int i;
10640 this_command_key_count = 0;
10641 this_command_key_count_reset = 0;
10642 this_single_command_key_start = 0;
10644 keys = XVECTOR (saved_keys)->contents;
10645 for (i = 0; i < XVECTOR (saved_keys)->size; i++)
10646 add_command_key (keys[i]);
10648 for (i = 0; i < SCHARS (function); i++)
10649 add_command_key (Faref (function, make_number (i)));
10651 add_command_key (make_number ('\015'));
10654 last_point_position = saved_last_point_position;
10655 last_point_position_buffer = saved_last_point_position_buffer;
10657 UNGCPRO;
10659 function = Fintern (function, Qnil);
10660 current_kboard->Vprefix_arg = prefixarg;
10661 Vthis_command = function;
10662 real_this_command = function;
10664 /* If enabled, show which key runs this command. */
10665 if (!NILP (Vsuggest_key_bindings)
10666 && NILP (Vexecuting_kbd_macro)
10667 && SYMBOLP (function))
10668 bindings = Fwhere_is_internal (function, Voverriding_local_map,
10669 Qt, Qnil, Qnil);
10670 else
10671 bindings = Qnil;
10673 value = Qnil;
10674 GCPRO3 (bindings, value, function);
10675 value = Fcommand_execute (function, Qt, Qnil, Qnil);
10677 /* If the command has a key binding, print it now. */
10678 if (!NILP (bindings)
10679 && ! (VECTORP (bindings) && EQ (Faref (bindings, make_number (0)),
10680 Qmouse_movement)))
10682 /* But first wait, and skip the message if there is input. */
10683 Lisp_Object waited;
10685 /* If this command displayed something in the echo area;
10686 wait a few seconds, then display our suggestion message. */
10687 if (NILP (echo_area_buffer[0]))
10688 waited = sit_for (make_number (0), 0, 2);
10689 else if (NUMBERP (Vsuggest_key_bindings))
10690 waited = sit_for (Vsuggest_key_bindings, 0, 2);
10691 else
10692 waited = sit_for (make_number (2), 0, 2);
10694 if (!NILP (waited) && ! CONSP (Vunread_command_events))
10696 Lisp_Object binding;
10697 char *newmessage;
10698 int message_p = push_message ();
10699 int count = SPECPDL_INDEX ();
10701 record_unwind_protect (pop_message_unwind, Qnil);
10702 binding = Fkey_description (bindings, Qnil);
10704 newmessage
10705 = (char *) alloca (SCHARS (SYMBOL_NAME (function))
10706 + SBYTES (binding)
10707 + 100);
10708 sprintf (newmessage, "You can run the command `%s' with %s",
10709 SDATA (SYMBOL_NAME (function)),
10710 SDATA (binding));
10711 message2_nolog (newmessage,
10712 strlen (newmessage),
10713 STRING_MULTIBYTE (binding));
10714 if (NUMBERP (Vsuggest_key_bindings))
10715 waited = sit_for (Vsuggest_key_bindings, 0, 2);
10716 else
10717 waited = sit_for (make_number (2), 0, 2);
10719 if (!NILP (waited) && message_p)
10720 restore_message ();
10722 unbind_to (count, Qnil);
10726 RETURN_UNGCPRO (value);
10730 /* Return nonzero if input events are pending. */
10733 detect_input_pending ()
10735 if (!input_pending)
10736 get_input_pending (&input_pending, 0);
10738 return input_pending;
10741 /* Return nonzero if input events other than mouse movements are
10742 pending. */
10745 detect_input_pending_ignore_squeezables ()
10747 if (!input_pending)
10748 get_input_pending (&input_pending, READABLE_EVENTS_IGNORE_SQUEEZABLES);
10750 return input_pending;
10753 /* Return nonzero if input events are pending, and run any pending timers. */
10756 detect_input_pending_run_timers (do_display)
10757 int do_display;
10759 int old_timers_run = timers_run;
10761 if (!input_pending)
10762 get_input_pending (&input_pending, READABLE_EVENTS_DO_TIMERS_NOW);
10764 if (old_timers_run != timers_run && do_display)
10766 redisplay_preserve_echo_area (8);
10767 /* The following fixes a bug when using lazy-lock with
10768 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10769 from an idle timer function. The symptom of the bug is that
10770 the cursor sometimes doesn't become visible until the next X
10771 event is processed. --gerd. */
10773 Lisp_Object tail, frame;
10774 FOR_EACH_FRAME (tail, frame)
10775 if (FRAME_RIF (XFRAME (frame)))
10776 FRAME_RIF (XFRAME (frame))->flush_display (XFRAME (frame));
10780 return input_pending;
10783 /* This is called in some cases before a possible quit.
10784 It cases the next call to detect_input_pending to recompute input_pending.
10785 So calling this function unnecessarily can't do any harm. */
10787 void
10788 clear_input_pending ()
10790 input_pending = 0;
10793 /* Return nonzero if there are pending requeued events.
10794 This isn't used yet. The hope is to make wait_reading_process_output
10795 call it, and return if it runs Lisp code that unreads something.
10796 The problem is, kbd_buffer_get_event needs to be fixed to know what
10797 to do in that case. It isn't trivial. */
10800 requeued_events_pending_p ()
10802 return (!NILP (Vunread_command_events) || unread_command_char != -1);
10806 DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
10807 doc: /* Return t if command input is currently available with no wait.
10808 Actually, the value is nil only if we can be sure that no input is available;
10809 if there is a doubt, the value is t. */)
10812 if (!NILP (Vunread_command_events) || unread_command_char != -1
10813 || !NILP (Vunread_post_input_method_events)
10814 || !NILP (Vunread_input_method_events))
10815 return (Qt);
10817 get_input_pending (&input_pending,
10818 READABLE_EVENTS_DO_TIMERS_NOW
10819 | READABLE_EVENTS_FILTER_EVENTS);
10820 return input_pending > 0 ? Qt : Qnil;
10823 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
10824 doc: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10827 Lisp_Object *keys = XVECTOR (recent_keys)->contents;
10828 Lisp_Object val;
10830 if (total_keys < NUM_RECENT_KEYS)
10831 return Fvector (total_keys, keys);
10832 else
10834 val = Fvector (NUM_RECENT_KEYS, keys);
10835 bcopy (keys + recent_keys_index,
10836 XVECTOR (val)->contents,
10837 (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
10838 bcopy (keys,
10839 XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
10840 recent_keys_index * sizeof (Lisp_Object));
10841 return val;
10845 DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
10846 doc: /* Return the key sequence that invoked this command.
10847 However, if the command has called `read-key-sequence', it returns
10848 the last key sequence that has been read.
10849 The value is a string or a vector.
10851 See also `this-command-keys-vector'. */)
10854 return make_event_array (this_command_key_count,
10855 XVECTOR (this_command_keys)->contents);
10858 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
10859 doc: /* Return the key sequence that invoked this command, as a vector.
10860 However, if the command has called `read-key-sequence', it returns
10861 the last key sequence that has been read.
10863 See also `this-command-keys'. */)
10866 return Fvector (this_command_key_count,
10867 XVECTOR (this_command_keys)->contents);
10870 DEFUN ("this-single-command-keys", Fthis_single_command_keys,
10871 Sthis_single_command_keys, 0, 0, 0,
10872 doc: /* Return the key sequence that invoked this command.
10873 More generally, it returns the last key sequence read, either by
10874 the command loop or by `read-key-sequence'.
10875 Unlike `this-command-keys', this function's value
10876 does not include prefix arguments.
10877 The value is always a vector. */)
10880 return Fvector (this_command_key_count
10881 - this_single_command_key_start,
10882 (XVECTOR (this_command_keys)->contents
10883 + this_single_command_key_start));
10886 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys,
10887 Sthis_single_command_raw_keys, 0, 0, 0,
10888 doc: /* Return the raw events that were read for this command.
10889 More generally, it returns the last key sequence read, either by
10890 the command loop or by `read-key-sequence'.
10891 Unlike `this-single-command-keys', this function's value
10892 shows the events before all translations (except for input methods).
10893 The value is always a vector. */)
10896 return Fvector (raw_keybuf_count,
10897 (XVECTOR (raw_keybuf)->contents));
10900 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
10901 Sreset_this_command_lengths, 0, 0, 0,
10902 doc: /* Make the unread events replace the last command and echo.
10903 Used in `universal-argument-other-key'.
10905 `universal-argument-other-key' rereads the event just typed.
10906 It then gets translated through `function-key-map'.
10907 The translated event has to replace the real events,
10908 both in the value of (this-command-keys) and in echoing.
10909 To achieve this, `universal-argument-other-key' calls
10910 `reset-this-command-lengths', which discards the record of reading
10911 these events the first time. */)
10914 this_command_key_count = before_command_key_count;
10915 if (this_command_key_count < this_single_command_key_start)
10916 this_single_command_key_start = this_command_key_count;
10918 echo_truncate (before_command_echo_length);
10920 /* Cause whatever we put into unread-command-events
10921 to echo as if it were being freshly read from the keyboard. */
10922 this_command_key_count_reset = 1;
10924 return Qnil;
10927 DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
10928 Sclear_this_command_keys, 0, 1, 0,
10929 doc: /* Clear out the vector that `this-command-keys' returns.
10930 Also clear the record of the last 100 events, unless optional arg
10931 KEEP-RECORD is non-nil. */)
10932 (keep_record)
10933 Lisp_Object keep_record;
10935 int i;
10937 this_command_key_count = 0;
10938 this_command_key_count_reset = 0;
10940 if (NILP (keep_record))
10942 for (i = 0; i < XVECTOR (recent_keys)->size; ++i)
10943 XVECTOR (recent_keys)->contents[i] = Qnil;
10944 total_keys = 0;
10945 recent_keys_index = 0;
10947 return Qnil;
10950 DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
10951 doc: /* Return the current depth in recursive edits. */)
10954 Lisp_Object temp;
10955 XSETFASTINT (temp, command_loop_level + minibuf_level);
10956 return temp;
10959 DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
10960 "FOpen dribble file: ",
10961 doc: /* Start writing all keyboard characters to a dribble file called FILE.
10962 If FILE is nil, close any open dribble file. */)
10963 (file)
10964 Lisp_Object file;
10966 if (dribble)
10968 BLOCK_INPUT;
10969 fclose (dribble);
10970 UNBLOCK_INPUT;
10971 dribble = 0;
10973 if (!NILP (file))
10975 file = Fexpand_file_name (file, Qnil);
10976 dribble = fopen (SDATA (file), "w");
10977 if (dribble == 0)
10978 report_file_error ("Opening dribble", Fcons (file, Qnil));
10980 return Qnil;
10983 DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
10984 doc: /* Discard the contents of the terminal input buffer.
10985 Also end any kbd macro being defined. */)
10988 if (!NILP (current_kboard->defining_kbd_macro))
10990 /* Discard the last command from the macro. */
10991 Fcancel_kbd_macro_events ();
10992 end_kbd_macro ();
10995 update_mode_lines++;
10997 Vunread_command_events = Qnil;
10998 unread_command_char = -1;
11000 discard_tty_input ();
11002 kbd_fetch_ptr = kbd_store_ptr;
11003 input_pending = 0;
11005 return Qnil;
11008 DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
11009 doc: /* Stop Emacs and return to superior process. You can resume later.
11010 If `cannot-suspend' is non-nil, or if the system doesn't support job
11011 control, run a subshell instead.
11013 If optional arg STUFFSTRING is non-nil, its characters are stuffed
11014 to be read as terminal input by Emacs's parent, after suspension.
11016 Before suspending, run the normal hook `suspend-hook'.
11017 After resumption run the normal hook `suspend-resume-hook'.
11019 Some operating systems cannot stop the Emacs process and resume it later.
11020 On such systems, Emacs starts a subshell instead of suspending. */)
11021 (stuffstring)
11022 Lisp_Object stuffstring;
11024 int count = SPECPDL_INDEX ();
11025 int old_height, old_width;
11026 int width, height;
11027 struct gcpro gcpro1;
11029 if (tty_list && tty_list->next)
11030 error ("There are other tty frames open; close them before suspending Emacs");
11032 if (!NILP (stuffstring))
11033 CHECK_STRING (stuffstring);
11035 /* Run the functions in suspend-hook. */
11036 if (!NILP (Vrun_hooks))
11037 call1 (Vrun_hooks, intern ("suspend-hook"));
11039 GCPRO1 (stuffstring);
11040 get_tty_size (fileno (CURTTY ()->input), &old_width, &old_height);
11041 reset_all_sys_modes ();
11042 /* sys_suspend can get an error if it tries to fork a subshell
11043 and the system resources aren't available for that. */
11044 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_all_sys_modes,
11045 Qnil);
11046 stuff_buffered_input (stuffstring);
11047 if (cannot_suspend)
11048 sys_subshell ();
11049 else
11050 sys_suspend ();
11051 unbind_to (count, Qnil);
11053 /* Check if terminal/window size has changed.
11054 Note that this is not useful when we are running directly
11055 with a window system; but suspend should be disabled in that case. */
11056 get_tty_size (fileno (CURTTY ()->input), &width, &height);
11057 if (width != old_width || height != old_height)
11058 change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
11060 /* Run suspend-resume-hook. */
11061 if (!NILP (Vrun_hooks))
11062 call1 (Vrun_hooks, intern ("suspend-resume-hook"));
11064 UNGCPRO;
11065 return Qnil;
11068 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
11069 Then in any case stuff anything Emacs has read ahead and not used. */
11071 void
11072 stuff_buffered_input (stuffstring)
11073 Lisp_Object stuffstring;
11075 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
11076 register unsigned char *p;
11078 if (STRINGP (stuffstring))
11080 register int count;
11082 p = SDATA (stuffstring);
11083 count = SBYTES (stuffstring);
11084 while (count-- > 0)
11085 stuff_char (*p++);
11086 stuff_char ('\n');
11089 /* Anything we have read ahead, put back for the shell to read. */
11090 /* ?? What should this do when we have multiple keyboards??
11091 Should we ignore anything that was typed in at the "wrong" kboard?
11093 rms: we should stuff everything back into the kboard
11094 it came from. */
11095 for (; kbd_fetch_ptr != kbd_store_ptr; kbd_fetch_ptr++)
11098 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
11099 kbd_fetch_ptr = kbd_buffer;
11100 if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
11101 stuff_char (kbd_fetch_ptr->code);
11103 clear_event (kbd_fetch_ptr);
11106 input_pending = 0;
11107 #endif /* SIGTSTP */
11110 void
11111 set_waiting_for_input (time_to_clear)
11112 EMACS_TIME *time_to_clear;
11114 input_available_clear_time = time_to_clear;
11116 /* Tell handle_interrupt to throw back to read_char, */
11117 waiting_for_input = 1;
11119 /* If handle_interrupt was called before and buffered a C-g,
11120 make it run again now, to avoid timing error. */
11121 if (!NILP (Vquit_flag))
11122 quit_throw_to_read_char ();
11125 void
11126 clear_waiting_for_input ()
11128 /* Tell handle_interrupt not to throw back to read_char, */
11129 waiting_for_input = 0;
11130 input_available_clear_time = 0;
11133 /* The SIGINT handler.
11135 If we have a frame on the controlling tty, we assume that the
11136 SIGINT was generated by C-g, so we call handle_interrupt.
11137 Otherwise, the handler kills Emacs. */
11139 static SIGTYPE
11140 interrupt_signal (signalnum) /* If we don't have an argument, */
11141 int signalnum; /* some compilers complain in signal calls. */
11143 /* Must preserve main program's value of errno. */
11144 int old_errno = errno;
11145 struct terminal *terminal;
11147 #if defined (USG) && !defined (POSIX_SIGNALS)
11148 /* USG systems forget handlers when they are used;
11149 must reestablish each time */
11150 signal (SIGINT, interrupt_signal);
11151 signal (SIGQUIT, interrupt_signal);
11152 #endif /* USG */
11154 SIGNAL_THREAD_CHECK (signalnum);
11156 /* See if we have an active terminal on our controlling tty. */
11157 terminal = get_named_tty ("/dev/tty");
11158 if (!terminal)
11160 /* If there are no frames there, let's pretend that we are a
11161 well-behaving UN*X program and quit. */
11162 Fkill_emacs (Qnil);
11164 else
11166 /* Otherwise, the SIGINT was probably generated by C-g. */
11168 /* Set internal_last_event_frame to the top frame of the
11169 controlling tty, if we have a frame there. We disable the
11170 interrupt key on secondary ttys, so the SIGINT must have come
11171 from the controlling tty. */
11172 internal_last_event_frame = terminal->display_info.tty->top_frame;
11174 handle_interrupt ();
11177 errno = old_errno;
11180 /* This routine is called at interrupt level in response to C-g.
11182 It is called from the SIGINT handler or kbd_buffer_store_event.
11184 If `waiting_for_input' is non zero, then unless `echoing' is
11185 nonzero, immediately throw back to read_char.
11187 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
11188 eval to throw, when it gets a chance. If quit-flag is already
11189 non-nil, it stops the job right away. */
11191 static void
11192 handle_interrupt ()
11194 char c;
11196 cancel_echoing ();
11198 /* XXX This code needs to be revised for multi-tty support. */
11199 if (!NILP (Vquit_flag) && get_named_tty ("/dev/tty"))
11201 /* If SIGINT isn't blocked, don't let us be interrupted by
11202 another SIGINT, it might be harmful due to non-reentrancy
11203 in I/O functions. */
11204 sigblock (sigmask (SIGINT));
11206 fflush (stdout);
11207 reset_all_sys_modes ();
11209 #ifdef SIGTSTP /* Support possible in later USG versions */
11211 * On systems which can suspend the current process and return to the original
11212 * shell, this command causes the user to end up back at the shell.
11213 * The "Auto-save" and "Abort" questions are not asked until
11214 * the user elects to return to emacs, at which point he can save the current
11215 * job and either dump core or continue.
11217 sys_suspend ();
11218 #else
11219 /* Perhaps should really fork an inferior shell?
11220 But that would not provide any way to get back
11221 to the original shell, ever. */
11222 printf ("No support for stopping a process on this operating system;\n");
11223 printf ("you can continue or abort.\n");
11224 #endif /* not SIGTSTP */
11225 #ifdef MSDOS
11226 /* We must remain inside the screen area when the internal terminal
11227 is used. Note that [Enter] is not echoed by dos. */
11228 cursor_to (SELECTED_FRAME (), 0, 0);
11229 #endif
11230 /* It doesn't work to autosave while GC is in progress;
11231 the code used for auto-saving doesn't cope with the mark bit. */
11232 if (!gc_in_progress)
11234 printf ("Auto-save? (y or n) ");
11235 fflush (stdout);
11236 if (((c = getchar ()) & ~040) == 'Y')
11238 Fdo_auto_save (Qt, Qnil);
11239 #ifdef MSDOS
11240 printf ("\r\nAuto-save done");
11241 #else /* not MSDOS */
11242 printf ("Auto-save done\n");
11243 #endif /* not MSDOS */
11245 while (c != '\n') c = getchar ();
11247 else
11249 /* During GC, it must be safe to reenable quitting again. */
11250 Vinhibit_quit = Qnil;
11251 #ifdef MSDOS
11252 printf ("\r\n");
11253 #endif /* not MSDOS */
11254 printf ("Garbage collection in progress; cannot auto-save now\r\n");
11255 printf ("but will instead do a real quit after garbage collection ends\r\n");
11256 fflush (stdout);
11259 #ifdef MSDOS
11260 printf ("\r\nAbort? (y or n) ");
11261 #else /* not MSDOS */
11262 printf ("Abort (and dump core)? (y or n) ");
11263 #endif /* not MSDOS */
11264 fflush (stdout);
11265 if (((c = getchar ()) & ~040) == 'Y')
11266 abort ();
11267 while (c != '\n') c = getchar ();
11268 #ifdef MSDOS
11269 printf ("\r\nContinuing...\r\n");
11270 #else /* not MSDOS */
11271 printf ("Continuing...\n");
11272 #endif /* not MSDOS */
11273 fflush (stdout);
11274 init_all_sys_modes ();
11275 sigfree ();
11277 else
11279 /* If executing a function that wants to be interrupted out of
11280 and the user has not deferred quitting by binding `inhibit-quit'
11281 then quit right away. */
11282 if (immediate_quit && NILP (Vinhibit_quit))
11284 struct gl_state_s saved;
11285 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
11287 immediate_quit = 0;
11288 sigfree ();
11289 saved = gl_state;
11290 GCPRO4 (saved.object, saved.global_code,
11291 saved.current_syntax_table, saved.old_prop);
11292 Fsignal (Qquit, Qnil);
11293 gl_state = saved;
11294 UNGCPRO;
11296 else
11297 /* Else request quit when it's safe */
11298 Vquit_flag = Qt;
11301 /* TODO: The longjmp in this call throws the NS event loop integration off,
11302 and it seems to do fine without this. Probably some attention
11303 needs to be paid to the setting of waiting_for_input in
11304 wait_reading_process_output() under HAVE_NS because of the call
11305 to ns_select there (needed because otherwise events aren't picked up
11306 outside of polling since we don't get SIGIO like X and we don't have a
11307 separate event loop thread like W32. */
11308 #ifndef HAVE_NS
11309 if (waiting_for_input && !echoing)
11310 quit_throw_to_read_char ();
11311 #endif
11314 /* Handle a C-g by making read_char return C-g. */
11316 void
11317 quit_throw_to_read_char ()
11319 sigfree ();
11320 /* Prevent another signal from doing this before we finish. */
11321 clear_waiting_for_input ();
11322 input_pending = 0;
11324 Vunread_command_events = Qnil;
11325 unread_command_char = -1;
11327 #if 0 /* Currently, sit_for is called from read_char without turning
11328 off polling. And that can call set_waiting_for_input.
11329 It seems to be harmless. */
11330 #ifdef POLL_FOR_INPUT
11331 /* May be > 1 if in recursive minibuffer. */
11332 if (poll_suppress_count == 0)
11333 abort ();
11334 #endif
11335 #endif
11336 if (FRAMEP (internal_last_event_frame)
11337 && !EQ (internal_last_event_frame, selected_frame))
11338 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame),
11339 0, 0, Qnil);
11341 _longjmp (getcjmp, 1);
11344 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode, Sset_input_interrupt_mode, 1, 1, 0,
11345 doc: /* Set interrupt mode of reading keyboard input.
11346 If INTERRUPT is non-nil, Emacs will use input interrupts;
11347 otherwise Emacs uses CBREAK mode.
11349 See also `current-input-mode'. */)
11350 (interrupt)
11351 Lisp_Object interrupt;
11353 int new_interrupt_input;
11354 #ifdef SIGIO
11355 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11356 #ifdef HAVE_X_WINDOWS
11357 if (x_display_list != NULL)
11359 /* When using X, don't give the user a real choice,
11360 because we haven't implemented the mechanisms to support it. */
11361 #ifdef NO_SOCK_SIGIO
11362 new_interrupt_input = 0;
11363 #else /* not NO_SOCK_SIGIO */
11364 new_interrupt_input = 1;
11365 #endif /* NO_SOCK_SIGIO */
11367 else
11368 #endif /* HAVE_X_WINDOWS */
11369 new_interrupt_input = !NILP (interrupt);
11370 #else /* not SIGIO */
11371 new_interrupt_input = 0;
11372 #endif /* not SIGIO */
11374 if (new_interrupt_input != interrupt_input)
11376 #ifdef POLL_FOR_INPUT
11377 stop_polling ();
11378 #endif
11379 #ifndef DOS_NT
11380 /* this causes startup screen to be restored and messes with the mouse */
11381 reset_all_sys_modes ();
11382 #endif
11383 interrupt_input = new_interrupt_input;
11384 #ifndef DOS_NT
11385 init_all_sys_modes ();
11386 #endif
11388 #ifdef POLL_FOR_INPUT
11389 poll_suppress_count = 1;
11390 start_polling ();
11391 #endif
11393 return Qnil;
11396 DEFUN ("set-output-flow-control", Fset_output_flow_control, Sset_output_flow_control, 1, 2, 0,
11397 doc: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
11398 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11399 C-q in key sequences.
11401 This setting only has an effect on tty terminals and only when
11402 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11404 See also `current-input-mode'. */)
11405 (flow, terminal)
11406 Lisp_Object flow, terminal;
11408 struct terminal *t = get_terminal (terminal, 1);
11409 struct tty_display_info *tty;
11410 if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
11411 return Qnil;
11412 tty = t->display_info.tty;
11414 if (tty->flow_control != !NILP (flow))
11416 #ifndef DOS_NT
11417 /* this causes startup screen to be restored and messes with the mouse */
11418 reset_sys_modes (tty);
11419 #endif
11421 tty->flow_control = !NILP (flow);
11423 #ifndef DOS_NT
11424 init_sys_modes (tty);
11425 #endif
11427 return Qnil;
11430 DEFUN ("set-input-meta-mode", Fset_input_meta_mode, Sset_input_meta_mode, 1, 2, 0,
11431 doc: /* Enable or disable 8-bit input on TERMINAL.
11432 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11433 bit as the Meta modifier.
11435 If META is nil, Emacs will ignore the top bit, on the assumption it is
11436 parity.
11438 Otherwise, Emacs will accept and pass through 8-bit input without
11439 specially interpreting the top bit.
11441 This setting only has an effect on tty terminal devices.
11443 Optional parameter TERMINAL specifies the tty terminal device to use.
11444 It may be a terminal object, a frame, or nil for the terminal used by
11445 the currently selected frame.
11447 See also `current-input-mode'. */)
11448 (meta, terminal)
11449 Lisp_Object meta, terminal;
11451 struct terminal *t = get_terminal (terminal, 1);
11452 struct tty_display_info *tty;
11453 int new_meta;
11455 if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
11456 return Qnil;
11457 tty = t->display_info.tty;
11459 if (NILP (meta))
11460 new_meta = 0;
11461 else if (EQ (meta, Qt))
11462 new_meta = 1;
11463 else
11464 new_meta = 2;
11466 if (tty->meta_key != new_meta)
11468 #ifndef DOS_NT
11469 /* this causes startup screen to be restored and messes with the mouse */
11470 reset_sys_modes (tty);
11471 #endif
11473 tty->meta_key = new_meta;
11475 #ifndef DOS_NT
11476 init_sys_modes (tty);
11477 #endif
11479 return Qnil;
11482 DEFUN ("set-quit-char", Fset_quit_char, Sset_quit_char, 1, 1, 0,
11483 doc: /* Specify character used for quitting.
11484 QUIT must be an ASCII character.
11486 This function only has an effect on the controlling tty of the Emacs
11487 process.
11489 See also `current-input-mode'. */)
11490 (quit)
11491 Lisp_Object quit;
11493 struct terminal *t = get_named_tty ("/dev/tty");
11494 struct tty_display_info *tty;
11495 if (t == NULL || (t->type != output_termcap && t->type != output_msdos_raw))
11496 return Qnil;
11497 tty = t->display_info.tty;
11499 if (NILP (quit) || !INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400)
11500 error ("QUIT must be an ASCII character");
11502 #ifndef DOS_NT
11503 /* this causes startup screen to be restored and messes with the mouse */
11504 reset_sys_modes (tty);
11505 #endif
11507 /* Don't let this value be out of range. */
11508 quit_char = XINT (quit) & (tty->meta_key == 0 ? 0177 : 0377);
11510 #ifndef DOS_NT
11511 init_sys_modes (tty);
11512 #endif
11514 return Qnil;
11517 DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
11518 doc: /* Set mode of reading keyboard input.
11519 First arg INTERRUPT non-nil means use input interrupts;
11520 nil means use CBREAK mode.
11521 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11522 (no effect except in CBREAK mode).
11523 Third arg META t means accept 8-bit input (for a Meta key).
11524 META nil means ignore the top bit, on the assumption it is parity.
11525 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11526 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11527 See also `current-input-mode'. */)
11528 (interrupt, flow, meta, quit)
11529 Lisp_Object interrupt, flow, meta, quit;
11531 Fset_input_interrupt_mode (interrupt);
11532 Fset_output_flow_control (flow, Qnil);
11533 Fset_input_meta_mode (meta, Qnil);
11534 if (!NILP (quit))
11535 Fset_quit_char (quit);
11536 return Qnil;
11539 DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
11540 doc: /* Return information about the way Emacs currently reads keyboard input.
11541 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11542 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11543 nil, Emacs is using CBREAK mode.
11544 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11545 terminal; this does not apply if Emacs uses interrupt-driven input.
11546 META is t if accepting 8-bit input with 8th bit as Meta flag.
11547 META nil means ignoring the top bit, on the assumption it is parity.
11548 META is neither t nor nil if accepting 8-bit input and using
11549 all 8 bits as the character code.
11550 QUIT is the character Emacs currently uses to quit.
11551 The elements of this list correspond to the arguments of
11552 `set-input-mode'. */)
11555 Lisp_Object val[4];
11556 struct frame *sf = XFRAME (selected_frame);
11558 val[0] = interrupt_input ? Qt : Qnil;
11559 if (FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
11561 val[1] = FRAME_TTY (sf)->flow_control ? Qt : Qnil;
11562 val[2] = (FRAME_TTY (sf)->meta_key == 2
11563 ? make_number (0)
11564 : (CURTTY ()->meta_key == 1 ? Qt : Qnil));
11566 else
11568 val[1] = Qnil;
11569 val[2] = Qt;
11571 XSETFASTINT (val[3], quit_char);
11573 return Flist (sizeof (val) / sizeof (val[0]), val);
11576 DEFUN ("posn-at-x-y", Fposn_at_x_y, Sposn_at_x_y, 2, 4, 0,
11577 doc: /* Return position information for pixel coordinates X and Y.
11578 By default, X and Y are relative to text area of the selected window.
11579 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11580 If optional fourth arg WHOLE is non-nil, X is relative to the left
11581 edge of the window.
11583 The return value is similar to a mouse click position:
11584 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11585 IMAGE (DX . DY) (WIDTH . HEIGHT))
11586 The `posn-' functions access elements of such lists. */)
11587 (x, y, frame_or_window, whole)
11588 Lisp_Object x, y, frame_or_window, whole;
11590 CHECK_NATNUM (x);
11591 CHECK_NATNUM (y);
11593 if (NILP (frame_or_window))
11594 frame_or_window = selected_window;
11596 if (WINDOWP (frame_or_window))
11598 struct window *w;
11600 CHECK_LIVE_WINDOW (frame_or_window);
11602 w = XWINDOW (frame_or_window);
11603 XSETINT (x, (XINT (x)
11604 + WINDOW_LEFT_EDGE_X (w)
11605 + (NILP (whole)
11606 ? window_box_left_offset (w, TEXT_AREA)
11607 : 0)));
11608 XSETINT (y, WINDOW_TO_FRAME_PIXEL_Y (w, XINT (y)));
11609 frame_or_window = w->frame;
11612 CHECK_LIVE_FRAME (frame_or_window);
11614 return make_lispy_position (XFRAME (frame_or_window), &x, &y, 0);
11617 DEFUN ("posn-at-point", Fposn_at_point, Sposn_at_point, 0, 2, 0,
11618 doc: /* Return position information for buffer POS in WINDOW.
11619 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11621 Return nil if position is not visible in window. Otherwise,
11622 the return value is similar to that returned by `event-start' for
11623 a mouse click at the upper left corner of the glyph corresponding
11624 to the given buffer position:
11625 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11626 IMAGE (DX . DY) (WIDTH . HEIGHT))
11627 The `posn-' functions access elements of such lists. */)
11628 (pos, window)
11629 Lisp_Object pos, window;
11631 Lisp_Object tem;
11633 if (NILP (window))
11634 window = selected_window;
11636 tem = Fpos_visible_in_window_p (pos, window, Qt);
11637 if (!NILP (tem))
11639 Lisp_Object x = XCAR (tem);
11640 Lisp_Object y = XCAR (XCDR (tem));
11642 /* Point invisible due to hscrolling? */
11643 if (XINT (x) < 0)
11644 return Qnil;
11645 tem = Fposn_at_x_y (x, y, window, Qnil);
11648 return tem;
11653 * Set up a new kboard object with reasonable initial values.
11655 void
11656 init_kboard (kb)
11657 KBOARD *kb;
11659 kb->Voverriding_terminal_local_map = Qnil;
11660 kb->Vlast_command = Qnil;
11661 kb->Vreal_last_command = Qnil;
11662 kb->Vkeyboard_translate_table = Qnil;
11663 kb->Vlast_repeatable_command = Qnil;
11664 kb->Vprefix_arg = Qnil;
11665 kb->Vlast_prefix_arg = Qnil;
11666 kb->kbd_queue = Qnil;
11667 kb->kbd_queue_has_data = 0;
11668 kb->immediate_echo = 0;
11669 kb->echo_string = Qnil;
11670 kb->echo_after_prompt = -1;
11671 kb->kbd_macro_buffer = 0;
11672 kb->kbd_macro_bufsize = 0;
11673 kb->defining_kbd_macro = Qnil;
11674 kb->Vlast_kbd_macro = Qnil;
11675 kb->reference_count = 0;
11676 kb->Vsystem_key_alist = Qnil;
11677 kb->system_key_syms = Qnil;
11678 kb->Vwindow_system = Qt; /* Unset. */
11679 kb->Vinput_decode_map = Fmake_sparse_keymap (Qnil);
11680 kb->Vlocal_function_key_map = Fmake_sparse_keymap (Qnil);
11681 Fset_keymap_parent (kb->Vlocal_function_key_map, Vfunction_key_map);
11682 kb->Vdefault_minibuffer_frame = Qnil;
11686 * Destroy the contents of a kboard object, but not the object itself.
11687 * We use this just before deleting it, or if we're going to initialize
11688 * it a second time.
11690 static void
11691 wipe_kboard (kb)
11692 KBOARD *kb;
11694 xfree (kb->kbd_macro_buffer);
11697 /* Free KB and memory referenced from it. */
11699 void
11700 delete_kboard (kb)
11701 KBOARD *kb;
11703 KBOARD **kbp;
11705 for (kbp = &all_kboards; *kbp != kb; kbp = &(*kbp)->next_kboard)
11706 if (*kbp == NULL)
11707 abort ();
11708 *kbp = kb->next_kboard;
11710 /* Prevent a dangling reference to KB. */
11711 if (kb == current_kboard
11712 && FRAMEP (selected_frame)
11713 && FRAME_LIVE_P (XFRAME (selected_frame)))
11715 current_kboard = FRAME_KBOARD (XFRAME (selected_frame));
11716 single_kboard = 0;
11717 if (current_kboard == kb)
11718 abort ();
11721 wipe_kboard (kb);
11722 xfree (kb);
11725 void
11726 init_keyboard ()
11728 /* This is correct before outermost invocation of the editor loop */
11729 command_loop_level = -1;
11730 immediate_quit = 0;
11731 quit_char = Ctl ('g');
11732 Vunread_command_events = Qnil;
11733 unread_command_char = -1;
11734 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
11735 total_keys = 0;
11736 recent_keys_index = 0;
11737 kbd_fetch_ptr = kbd_buffer;
11738 kbd_store_ptr = kbd_buffer;
11739 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11740 do_mouse_tracking = Qnil;
11741 #endif
11742 input_pending = 0;
11743 interrupt_input_blocked = 0;
11744 interrupt_input_pending = 0;
11745 #ifdef SYNC_INPUT
11746 pending_signals = 0;
11747 #endif
11749 /* This means that command_loop_1 won't try to select anything the first
11750 time through. */
11751 internal_last_event_frame = Qnil;
11752 Vlast_event_frame = internal_last_event_frame;
11754 current_kboard = initial_kboard;
11755 /* Re-initialize the keyboard again. */
11756 wipe_kboard (current_kboard);
11757 init_kboard (current_kboard);
11758 /* A value of nil for Vwindow_system normally means a tty, but we also use
11759 it for the initial terminal since there is no window system there. */
11760 current_kboard->Vwindow_system = Qnil;
11762 if (!noninteractive)
11764 /* Before multi-tty support, these handlers used to be installed
11765 only if the current session was a tty session. Now an Emacs
11766 session may have multiple display types, so we always handle
11767 SIGINT. There is special code in interrupt_signal to exit
11768 Emacs on SIGINT when there are no termcap frames on the
11769 controlling terminal. */
11770 signal (SIGINT, interrupt_signal);
11771 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
11772 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11773 SIGQUIT and we can't tell which one it will give us. */
11774 signal (SIGQUIT, interrupt_signal);
11775 #endif /* HAVE_TERMIO */
11777 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11778 #ifdef SIGIO
11779 if (!noninteractive)
11780 signal (SIGIO, input_available_signal);
11781 #endif /* SIGIO */
11783 /* Use interrupt input by default, if it works and noninterrupt input
11784 has deficiencies. */
11786 #ifdef INTERRUPT_INPUT
11787 interrupt_input = 1;
11788 #else
11789 interrupt_input = 0;
11790 #endif
11792 sigfree ();
11793 dribble = 0;
11795 if (keyboard_init_hook)
11796 (*keyboard_init_hook) ();
11798 #ifdef POLL_FOR_INPUT
11799 poll_timer = NULL;
11800 poll_suppress_count = 1;
11801 start_polling ();
11802 #endif
11805 /* This type's only use is in syms_of_keyboard, to initialize the
11806 event header symbols and put properties on them. */
11807 struct event_head {
11808 Lisp_Object *var;
11809 char *name;
11810 Lisp_Object *kind;
11813 struct event_head head_table[] = {
11814 {&Qmouse_movement, "mouse-movement", &Qmouse_movement},
11815 {&Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement},
11816 {&Qswitch_frame, "switch-frame", &Qswitch_frame},
11817 {&Qdelete_frame, "delete-frame", &Qdelete_frame},
11818 {&Qiconify_frame, "iconify-frame", &Qiconify_frame},
11819 {&Qmake_frame_visible, "make-frame-visible", &Qmake_frame_visible},
11820 /* `select-window' should be handled just like `switch-frame'
11821 in read_key_sequence. */
11822 {&Qselect_window, "select-window", &Qswitch_frame}
11825 void
11826 syms_of_keyboard ()
11828 pending_funcalls = Qnil;
11829 staticpro (&pending_funcalls);
11831 Vlispy_mouse_stem = make_pure_c_string ("mouse");
11832 staticpro (&Vlispy_mouse_stem);
11834 /* Tool-bars. */
11835 QCimage = intern_c_string (":image");
11836 staticpro (&QCimage);
11838 staticpro (&Qhelp_echo);
11839 Qhelp_echo = intern_c_string ("help-echo");
11841 staticpro (&Qrtl);
11842 Qrtl = intern_c_string (":rtl");
11844 staticpro (&item_properties);
11845 item_properties = Qnil;
11847 staticpro (&tool_bar_item_properties);
11848 tool_bar_item_properties = Qnil;
11849 staticpro (&tool_bar_items_vector);
11850 tool_bar_items_vector = Qnil;
11852 staticpro (&real_this_command);
11853 real_this_command = Qnil;
11855 Qtimer_event_handler = intern_c_string ("timer-event-handler");
11856 staticpro (&Qtimer_event_handler);
11858 Qdisabled_command_function = intern_c_string ("disabled-command-function");
11859 staticpro (&Qdisabled_command_function);
11861 Qself_insert_command = intern_c_string ("self-insert-command");
11862 staticpro (&Qself_insert_command);
11864 Qforward_char = intern_c_string ("forward-char");
11865 staticpro (&Qforward_char);
11867 Qbackward_char = intern_c_string ("backward-char");
11868 staticpro (&Qbackward_char);
11870 Qdisabled = intern_c_string ("disabled");
11871 staticpro (&Qdisabled);
11873 Qundefined = intern_c_string ("undefined");
11874 staticpro (&Qundefined);
11876 Qpre_command_hook = intern_c_string ("pre-command-hook");
11877 staticpro (&Qpre_command_hook);
11879 Qpost_command_hook = intern_c_string ("post-command-hook");
11880 staticpro (&Qpost_command_hook);
11882 Qdeferred_action_function = intern_c_string ("deferred-action-function");
11883 staticpro (&Qdeferred_action_function);
11885 Qcommand_hook_internal = intern_c_string ("command-hook-internal");
11886 staticpro (&Qcommand_hook_internal);
11888 Qfunction_key = intern_c_string ("function-key");
11889 staticpro (&Qfunction_key);
11890 Qmouse_click = intern_c_string ("mouse-click");
11891 staticpro (&Qmouse_click);
11892 #if defined (WINDOWSNT)
11893 Qlanguage_change = intern_c_string ("language-change");
11894 staticpro (&Qlanguage_change);
11895 #endif
11896 Qdrag_n_drop = intern_c_string ("drag-n-drop");
11897 staticpro (&Qdrag_n_drop);
11899 Qsave_session = intern_c_string ("save-session");
11900 staticpro (&Qsave_session);
11902 #ifdef HAVE_DBUS
11903 Qdbus_event = intern_c_string ("dbus-event");
11904 staticpro (&Qdbus_event);
11905 #endif
11907 Qconfig_changed_event = intern_c_string ("config-changed-event");
11908 staticpro (&Qconfig_changed_event);
11910 Qmenu_enable = intern_c_string ("menu-enable");
11911 staticpro (&Qmenu_enable);
11912 QCenable = intern_c_string (":enable");
11913 staticpro (&QCenable);
11914 QCvisible = intern_c_string (":visible");
11915 staticpro (&QCvisible);
11916 QChelp = intern_c_string (":help");
11917 staticpro (&QChelp);
11918 QCfilter = intern_c_string (":filter");
11919 staticpro (&QCfilter);
11920 QCbutton = intern_c_string (":button");
11921 staticpro (&QCbutton);
11922 QCkeys = intern_c_string (":keys");
11923 staticpro (&QCkeys);
11924 QCkey_sequence = intern_c_string (":key-sequence");
11925 staticpro (&QCkey_sequence);
11926 QCtoggle = intern_c_string (":toggle");
11927 staticpro (&QCtoggle);
11928 QCradio = intern_c_string (":radio");
11929 staticpro (&QCradio);
11931 Qmode_line = intern_c_string ("mode-line");
11932 staticpro (&Qmode_line);
11933 Qvertical_line = intern_c_string ("vertical-line");
11934 staticpro (&Qvertical_line);
11935 Qvertical_scroll_bar = intern_c_string ("vertical-scroll-bar");
11936 staticpro (&Qvertical_scroll_bar);
11937 Qmenu_bar = intern_c_string ("menu-bar");
11938 staticpro (&Qmenu_bar);
11940 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11941 Qmouse_fixup_help_message = intern_c_string ("mouse-fixup-help-message");
11942 staticpro (&Qmouse_fixup_help_message);
11943 #endif
11945 Qabove_handle = intern_c_string ("above-handle");
11946 staticpro (&Qabove_handle);
11947 Qhandle = intern_c_string ("handle");
11948 staticpro (&Qhandle);
11949 Qbelow_handle = intern_c_string ("below-handle");
11950 staticpro (&Qbelow_handle);
11951 Qup = intern_c_string ("up");
11952 staticpro (&Qup);
11953 Qdown = intern_c_string ("down");
11954 staticpro (&Qdown);
11955 Qtop = intern_c_string ("top");
11956 staticpro (&Qtop);
11957 Qbottom = intern_c_string ("bottom");
11958 staticpro (&Qbottom);
11959 Qend_scroll = intern_c_string ("end-scroll");
11960 staticpro (&Qend_scroll);
11961 Qratio = intern_c_string ("ratio");
11962 staticpro (&Qratio);
11964 Qevent_kind = intern_c_string ("event-kind");
11965 staticpro (&Qevent_kind);
11966 Qevent_symbol_elements = intern_c_string ("event-symbol-elements");
11967 staticpro (&Qevent_symbol_elements);
11968 Qevent_symbol_element_mask = intern_c_string ("event-symbol-element-mask");
11969 staticpro (&Qevent_symbol_element_mask);
11970 Qmodifier_cache = intern_c_string ("modifier-cache");
11971 staticpro (&Qmodifier_cache);
11973 Qrecompute_lucid_menubar = intern_c_string ("recompute-lucid-menubar");
11974 staticpro (&Qrecompute_lucid_menubar);
11975 Qactivate_menubar_hook = intern_c_string ("activate-menubar-hook");
11976 staticpro (&Qactivate_menubar_hook);
11978 Qpolling_period = intern_c_string ("polling-period");
11979 staticpro (&Qpolling_period);
11981 Qinput_method_function = intern_c_string ("input-method-function");
11982 staticpro (&Qinput_method_function);
11984 Qinput_method_exit_on_first_char = intern_c_string ("input-method-exit-on-first-char");
11985 staticpro (&Qinput_method_exit_on_first_char);
11986 Qinput_method_use_echo_area = intern_c_string ("input-method-use-echo-area");
11987 staticpro (&Qinput_method_use_echo_area);
11989 Fset (Qinput_method_exit_on_first_char, Qnil);
11990 Fset (Qinput_method_use_echo_area, Qnil);
11992 last_point_position_buffer = Qnil;
11993 last_point_position_window = Qnil;
11996 struct event_head *p;
11998 for (p = head_table;
11999 p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
12000 p++)
12002 *p->var = intern_c_string (p->name);
12003 staticpro (p->var);
12004 Fput (*p->var, Qevent_kind, *p->kind);
12005 Fput (*p->var, Qevent_symbol_elements, Fcons (*p->var, Qnil));
12009 button_down_location = Fmake_vector (make_number (5), Qnil);
12010 staticpro (&button_down_location);
12011 mouse_syms = Fmake_vector (make_number (5), Qnil);
12012 staticpro (&mouse_syms);
12013 wheel_syms = Fmake_vector (make_number (sizeof (lispy_wheel_names)
12014 / sizeof (lispy_wheel_names[0])),
12015 Qnil);
12016 staticpro (&wheel_syms);
12019 int i;
12020 int len = sizeof (modifier_names) / sizeof (modifier_names[0]);
12022 modifier_symbols = Fmake_vector (make_number (len), Qnil);
12023 for (i = 0; i < len; i++)
12024 if (modifier_names[i])
12025 XVECTOR (modifier_symbols)->contents[i] = intern_c_string (modifier_names[i]);
12026 staticpro (&modifier_symbols);
12029 recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
12030 staticpro (&recent_keys);
12032 this_command_keys = Fmake_vector (make_number (40), Qnil);
12033 staticpro (&this_command_keys);
12035 raw_keybuf = Fmake_vector (make_number (30), Qnil);
12036 staticpro (&raw_keybuf);
12038 Qextended_command_history = intern_c_string ("extended-command-history");
12039 Fset (Qextended_command_history, Qnil);
12040 staticpro (&Qextended_command_history);
12042 accent_key_syms = Qnil;
12043 staticpro (&accent_key_syms);
12045 func_key_syms = Qnil;
12046 staticpro (&func_key_syms);
12048 drag_n_drop_syms = Qnil;
12049 staticpro (&drag_n_drop_syms);
12051 unread_switch_frame = Qnil;
12052 staticpro (&unread_switch_frame);
12054 internal_last_event_frame = Qnil;
12055 staticpro (&internal_last_event_frame);
12057 read_key_sequence_cmd = Qnil;
12058 staticpro (&read_key_sequence_cmd);
12060 menu_bar_one_keymap_changed_items = Qnil;
12061 staticpro (&menu_bar_one_keymap_changed_items);
12063 menu_bar_items_vector = Qnil;
12064 staticpro (&menu_bar_items_vector);
12066 help_form_saved_window_configs = Qnil;
12067 staticpro (&help_form_saved_window_configs);
12069 defsubr (&Scurrent_idle_time);
12070 defsubr (&Sevent_symbol_parse_modifiers);
12071 defsubr (&Sevent_convert_list);
12072 defsubr (&Sread_key_sequence);
12073 defsubr (&Sread_key_sequence_vector);
12074 defsubr (&Srecursive_edit);
12075 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
12076 defsubr (&Strack_mouse);
12077 #endif
12078 defsubr (&Sinput_pending_p);
12079 defsubr (&Scommand_execute);
12080 defsubr (&Srecent_keys);
12081 defsubr (&Sthis_command_keys);
12082 defsubr (&Sthis_command_keys_vector);
12083 defsubr (&Sthis_single_command_keys);
12084 defsubr (&Sthis_single_command_raw_keys);
12085 defsubr (&Sreset_this_command_lengths);
12086 defsubr (&Sclear_this_command_keys);
12087 defsubr (&Ssuspend_emacs);
12088 defsubr (&Sabort_recursive_edit);
12089 defsubr (&Sexit_recursive_edit);
12090 defsubr (&Srecursion_depth);
12091 defsubr (&Stop_level);
12092 defsubr (&Sdiscard_input);
12093 defsubr (&Sopen_dribble_file);
12094 defsubr (&Sset_input_interrupt_mode);
12095 defsubr (&Sset_output_flow_control);
12096 defsubr (&Sset_input_meta_mode);
12097 defsubr (&Sset_quit_char);
12098 defsubr (&Sset_input_mode);
12099 defsubr (&Scurrent_input_mode);
12100 defsubr (&Sexecute_extended_command);
12101 defsubr (&Sposn_at_point);
12102 defsubr (&Sposn_at_x_y);
12104 DEFVAR_LISP ("last-command-event", &last_command_event,
12105 doc: /* Last input event that was part of a command. */);
12107 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
12108 doc: /* Last input event in a command, except for mouse menu events.
12109 Mouse menus give back keys that don't look like mouse events;
12110 this variable holds the actual mouse event that led to the menu,
12111 so that you can determine whether the command was run by mouse or not. */);
12113 DEFVAR_LISP ("last-input-event", &last_input_event,
12114 doc: /* Last input event. */);
12116 DEFVAR_LISP ("unread-command-events", &Vunread_command_events,
12117 doc: /* List of events to be read as the command input.
12118 These events are processed first, before actual keyboard input.
12119 Events read from this list are not normally added to `this-command-keys',
12120 as they will already have been added once as they were read for the first time.
12121 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
12122 Vunread_command_events = Qnil;
12124 DEFVAR_INT ("unread-command-char", &unread_command_char,
12125 doc: /* If not -1, an object to be read as next command input event. */);
12127 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events,
12128 doc: /* List of events to be processed as input by input methods.
12129 These events are processed before `unread-command-events'
12130 and actual keyboard input, but are not given to `input-method-function'. */);
12131 Vunread_post_input_method_events = Qnil;
12133 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events,
12134 doc: /* List of events to be processed as input by input methods.
12135 These events are processed after `unread-command-events', but
12136 before actual keyboard input.
12137 If there's an active input method, the events are given to
12138 `input-method-function'. */);
12139 Vunread_input_method_events = Qnil;
12141 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char,
12142 doc: /* Meta-prefix character code.
12143 Meta-foo as command input turns into this character followed by foo. */);
12144 XSETINT (meta_prefix_char, 033);
12146 DEFVAR_KBOARD ("last-command", Vlast_command,
12147 doc: /* The last command executed.
12148 Normally a symbol with a function definition, but can be whatever was found
12149 in the keymap, or whatever the variable `this-command' was set to by that
12150 command.
12152 The value `mode-exit' is special; it means that the previous command
12153 read an event that told it to exit, and it did so and unread that event.
12154 In other words, the present command is the event that made the previous
12155 command exit.
12157 The value `kill-region' is special; it means that the previous command
12158 was a kill command.
12160 `last-command' has a separate binding for each terminal device.
12161 See Info node `(elisp)Multiple Terminals'. */);
12163 DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
12164 doc: /* Same as `last-command', but never altered by Lisp code. */);
12166 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command,
12167 doc: /* Last command that may be repeated.
12168 The last command executed that was not bound to an input event.
12169 This is the command `repeat' will try to repeat. */);
12171 DEFVAR_LISP ("this-command", &Vthis_command,
12172 doc: /* The command now being executed.
12173 The command can set this variable; whatever is put here
12174 will be in `last-command' during the following command. */);
12175 Vthis_command = Qnil;
12177 DEFVAR_LISP ("this-command-keys-shift-translated",
12178 &Vthis_command_keys_shift_translated,
12179 doc: /* Non-nil if the key sequence activating this command was shift-translated.
12180 Shift-translation occurs when there is no binding for the key sequence
12181 as entered, but a binding was found by changing an upper-case letter
12182 to lower-case, or a shifted function key to an unshifted one. */);
12183 Vthis_command_keys_shift_translated = Qnil;
12185 DEFVAR_LISP ("this-original-command", &Vthis_original_command,
12186 doc: /* The command bound to the current key sequence before remapping.
12187 It equals `this-command' if the original command was not remapped through
12188 any of the active keymaps. Otherwise, the value of `this-command' is the
12189 result of looking up the original command in the active keymaps. */);
12190 Vthis_original_command = Qnil;
12192 DEFVAR_INT ("auto-save-interval", &auto_save_interval,
12193 doc: /* *Number of input events between auto-saves.
12194 Zero means disable autosaving due to number of characters typed. */);
12195 auto_save_interval = 300;
12197 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout,
12198 doc: /* *Number of seconds idle time before auto-save.
12199 Zero or nil means disable auto-saving due to idleness.
12200 After auto-saving due to this many seconds of idle time,
12201 Emacs also does a garbage collection if that seems to be warranted. */);
12202 XSETFASTINT (Vauto_save_timeout, 30);
12204 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes,
12205 doc: /* *Nonzero means echo unfinished commands after this many seconds of pause.
12206 The value may be integer or floating point. */);
12207 Vecho_keystrokes = make_number (1);
12209 DEFVAR_INT ("polling-period", &polling_period,
12210 doc: /* *Interval between polling for input during Lisp execution.
12211 The reason for polling is to make C-g work to stop a running program.
12212 Polling is needed only when using X windows and SIGIO does not work.
12213 Polling is automatically disabled in all other cases. */);
12214 polling_period = 2;
12216 DEFVAR_LISP ("double-click-time", &Vdouble_click_time,
12217 doc: /* *Maximum time between mouse clicks to make a double-click.
12218 Measured in milliseconds. The value nil means disable double-click
12219 recognition; t means double-clicks have no time limit and are detected
12220 by position only. */);
12221 Vdouble_click_time = make_number (500);
12223 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz,
12224 doc: /* *Maximum mouse movement between clicks to make a double-click.
12225 On window-system frames, value is the number of pixels the mouse may have
12226 moved horizontally or vertically between two clicks to make a double-click.
12227 On non window-system frames, value is interpreted in units of 1/8 characters
12228 instead of pixels.
12230 This variable is also the threshold for motion of the mouse
12231 to count as a drag. */);
12232 double_click_fuzz = 3;
12234 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus,
12235 doc: /* *Non-nil means inhibit local map menu bar menus. */);
12236 inhibit_local_menu_bar_menus = 0;
12238 DEFVAR_INT ("num-input-keys", &num_input_keys,
12239 doc: /* Number of complete key sequences read as input so far.
12240 This includes key sequences read from keyboard macros.
12241 The number is effectively the number of interactive command invocations. */);
12242 num_input_keys = 0;
12244 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events,
12245 doc: /* Number of input events read from the keyboard so far.
12246 This does not include events generated by keyboard macros. */);
12247 num_nonmacro_input_events = 0;
12249 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
12250 doc: /* The frame in which the most recently read event occurred.
12251 If the last event came from a keyboard macro, this is set to `macro'. */);
12252 Vlast_event_frame = Qnil;
12254 /* This variable is set up in sysdep.c. */
12255 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char,
12256 doc: /* The ERASE character as set by the user with stty. */);
12258 DEFVAR_LISP ("help-char", &Vhelp_char,
12259 doc: /* Character to recognize as meaning Help.
12260 When it is read, do `(eval help-form)', and display result if it's a string.
12261 If the value of `help-form' is nil, this char can be read normally. */);
12262 XSETINT (Vhelp_char, Ctl ('H'));
12264 DEFVAR_LISP ("help-event-list", &Vhelp_event_list,
12265 doc: /* List of input events to recognize as meaning Help.
12266 These work just like the value of `help-char' (see that). */);
12267 Vhelp_event_list = Qnil;
12269 DEFVAR_LISP ("help-form", &Vhelp_form,
12270 doc: /* Form to execute when character `help-char' is read.
12271 If the form returns a string, that string is displayed.
12272 If `help-form' is nil, the help char is not recognized. */);
12273 Vhelp_form = Qnil;
12275 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command,
12276 doc: /* Command to run when `help-char' character follows a prefix key.
12277 This command is used only when there is no actual binding
12278 for that character after that prefix key. */);
12279 Vprefix_help_command = Qnil;
12281 DEFVAR_LISP ("top-level", &Vtop_level,
12282 doc: /* Form to evaluate when Emacs starts up.
12283 Useful to set before you dump a modified Emacs. */);
12284 Vtop_level = Qnil;
12286 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table,
12287 doc: /* Translate table for local keyboard input, or nil.
12288 If non-nil, the value should be a char-table. Each character read
12289 from the keyboard is looked up in this char-table. If the value found
12290 there is non-nil, then it is used instead of the actual input character.
12292 The value can also be a string or vector, but this is considered obsolete.
12293 If it is a string or vector of length N, character codes N and up are left
12294 untranslated. In a vector, an element which is nil means "no translation".
12296 This is applied to the characters supplied to input methods, not their
12297 output. See also `translation-table-for-input'.
12299 This variable has a separate binding for each terminal.
12300 See Info node `(elisp)Multiple Terminals'. */);
12302 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
12303 doc: /* Non-nil means to always spawn a subshell instead of suspending.
12304 \(Even if the operating system has support for stopping a process.\) */);
12305 cannot_suspend = 0;
12307 DEFVAR_BOOL ("menu-prompting", &menu_prompting,
12308 doc: /* Non-nil means prompt with menus when appropriate.
12309 This is done when reading from a keymap that has a prompt string,
12310 for elements that have prompt strings.
12311 The menu is displayed on the screen
12312 if X menus were enabled at configuration
12313 time and the previous event was a mouse click prefix key.
12314 Otherwise, menu prompting uses the echo area. */);
12315 menu_prompting = 1;
12317 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,
12318 doc: /* Character to see next line of menu prompt.
12319 Type this character while in a menu prompt to rotate around the lines of it. */);
12320 XSETINT (menu_prompt_more_char, ' ');
12322 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers,
12323 doc: /* A mask of additional modifier keys to use with every keyboard character.
12324 Emacs applies the modifiers of the character stored here to each keyboard
12325 character it reads. For example, after evaluating the expression
12326 (setq extra-keyboard-modifiers ?\\C-x)
12327 all input characters will have the control modifier applied to them.
12329 Note that the character ?\\C-@, equivalent to the integer zero, does
12330 not count as a control character; rather, it counts as a character
12331 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
12332 cancels any modification. */);
12333 extra_keyboard_modifiers = 0;
12335 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark,
12336 doc: /* If an editing command sets this to t, deactivate the mark afterward.
12337 The command loop sets this to nil before each command,
12338 and tests the value when the command returns.
12339 Buffer modification stores t in this variable. */);
12340 Vdeactivate_mark = Qnil;
12341 Qdeactivate_mark = intern_c_string ("deactivate-mark");
12342 staticpro (&Qdeactivate_mark);
12344 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
12345 doc: /* Temporary storage of `pre-command-hook' or `post-command-hook'. */);
12346 Vcommand_hook_internal = Qnil;
12348 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook,
12349 doc: /* Normal hook run before each command is executed.
12350 If an unhandled error happens in running this hook,
12351 the hook value is set to nil, since otherwise the error
12352 might happen repeatedly and make Emacs nonfunctional. */);
12353 Vpre_command_hook = Qnil;
12355 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook,
12356 doc: /* Normal hook run after each command is executed.
12357 If an unhandled error happens in running this hook,
12358 the hook value is set to nil, since otherwise the error
12359 might happen repeatedly and make Emacs nonfunctional. */);
12360 Vpost_command_hook = Qnil;
12362 #if 0
12363 DEFVAR_LISP ("echo-area-clear-hook", ...,
12364 doc: /* Normal hook run when clearing the echo area. */);
12365 #endif
12366 Qecho_area_clear_hook = intern_c_string ("echo-area-clear-hook");
12367 staticpro (&Qecho_area_clear_hook);
12368 Fset (Qecho_area_clear_hook, Qnil);
12370 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag,
12371 doc: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
12372 Vlucid_menu_bar_dirty_flag = Qnil;
12374 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items,
12375 doc: /* List of menu bar items to move to the end of the menu bar.
12376 The elements of the list are event types that may have menu bar bindings. */);
12377 Vmenu_bar_final_items = Qnil;
12379 DEFVAR_KBOARD ("overriding-terminal-local-map",
12380 Voverriding_terminal_local_map,
12381 doc: /* Per-terminal keymap that overrides all other local keymaps.
12382 If this variable is non-nil, it is used as a keymap instead of the
12383 buffer's local map, and the minor mode keymaps and text property keymaps.
12384 It also replaces `overriding-local-map'.
12386 This variable is intended to let commands such as `universal-argument'
12387 set up a different keymap for reading the next command.
12389 `overriding-terminal-local-map' has a separate binding for each
12390 terminal device.
12391 See Info node `(elisp)Multiple Terminals'. */);
12393 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
12394 doc: /* Keymap that overrides all other local keymaps.
12395 If this variable is non-nil, it is used as a keymap--replacing the
12396 buffer's local map, the minor mode keymaps, and char property keymaps. */);
12397 Voverriding_local_map = Qnil;
12399 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag,
12400 doc: /* Non-nil means `overriding-local-map' applies to the menu bar.
12401 Otherwise, the menu bar continues to reflect the buffer's local map
12402 and the minor mode maps regardless of `overriding-local-map'. */);
12403 Voverriding_local_map_menu_flag = Qnil;
12405 DEFVAR_LISP ("special-event-map", &Vspecial_event_map,
12406 doc: /* Keymap defining bindings for special events to execute at low level. */);
12407 Vspecial_event_map = Fcons (intern_c_string ("keymap"), Qnil);
12409 DEFVAR_LISP ("track-mouse", &do_mouse_tracking,
12410 doc: /* *Non-nil means generate motion events for mouse motion. */);
12412 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist,
12413 doc: /* Alist of system-specific X windows key symbols.
12414 Each element should have the form (N . SYMBOL) where N is the
12415 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12416 and SYMBOL is its name.
12418 `system-key-alist' has a separate binding for each terminal device.
12419 See Info node `(elisp)Multiple Terminals'. */);
12421 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map,
12422 doc: /* Keymap that translates key sequences to key sequences during input.
12423 This is used mainly for mapping key sequences into some preferred
12424 key events (symbols).
12426 The `read-key-sequence' function replaces any subsequence bound by
12427 `local-function-key-map' with its binding. More precisely, when the
12428 active keymaps have no binding for the current key sequence but
12429 `local-function-key-map' binds a suffix of the sequence to a vector or
12430 string, `read-key-sequence' replaces the matching suffix with its
12431 binding, and continues with the new sequence.
12433 If the binding is a function, it is called with one argument (the prompt)
12434 and its return value (a key sequence) is used.
12436 The events that come from bindings in `local-function-key-map' are not
12437 themselves looked up in `local-function-key-map'.
12439 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12440 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12441 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12442 typing `ESC O P x' would return [f1 x].
12444 `local-function-key-map' has a separate binding for each terminal
12445 device. See Info node `(elisp)Multiple Terminals'. If you need to
12446 define a binding on all terminals, change `function-key-map'
12447 instead. Initially, `local-function-key-map' is an empty keymap that
12448 has `function-key-map' as its parent on all terminal devices. */);
12450 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map,
12451 doc: /* Keymap that decodes input escape sequences.
12452 This is used mainly for mapping ASCII function key sequences into
12453 real Emacs function key events (symbols).
12455 The `read-key-sequence' function replaces any subsequence bound by
12456 `input-decode-map' with its binding. Contrary to `function-key-map',
12457 this map applies its rebinding regardless of the presence of an ordinary
12458 binding. So it is more like `key-translation-map' except that it applies
12459 before `function-key-map' rather than after.
12461 If the binding is a function, it is called with one argument (the prompt)
12462 and its return value (a key sequence) is used.
12464 The events that come from bindings in `input-decode-map' are not
12465 themselves looked up in `input-decode-map'.
12467 This variable is keyboard-local. */);
12469 DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
12470 doc: /* The parent keymap of all `local-function-key-map' instances.
12471 Function key definitions that apply to all terminal devices should go
12472 here. If a mapping is defined in both the current
12473 `local-function-key-map' binding and this variable, then the local
12474 definition will take precendence. */);
12475 Vfunction_key_map = Fmake_sparse_keymap (Qnil);
12477 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map,
12478 doc: /* Keymap of key translations that can override keymaps.
12479 This keymap works like `function-key-map', but comes after that,
12480 and its non-prefix bindings override ordinary bindings.
12481 Another difference is that it is global rather than keyboard-local. */);
12482 Vkey_translation_map = Fmake_sparse_keymap (Qnil);
12484 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list,
12485 doc: /* List of deferred actions to be performed at a later time.
12486 The precise format isn't relevant here; we just check whether it is nil. */);
12487 Vdeferred_action_list = Qnil;
12489 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function,
12490 doc: /* Function to call to handle deferred actions, after each command.
12491 This function is called with no arguments after each command
12492 whenever `deferred-action-list' is non-nil. */);
12493 Vdeferred_action_function = Qnil;
12495 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings,
12496 doc: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12497 The value can be a length of time to show the message for.
12498 If the value is non-nil and not a number, we wait 2 seconds. */);
12499 Vsuggest_key_bindings = Qt;
12501 DEFVAR_LISP ("timer-list", &Vtimer_list,
12502 doc: /* List of active absolute time timers in order of increasing time. */);
12503 Vtimer_list = Qnil;
12505 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list,
12506 doc: /* List of active idle-time timers in order of increasing time. */);
12507 Vtimer_idle_list = Qnil;
12509 DEFVAR_LISP ("input-method-function", &Vinput_method_function,
12510 doc: /* If non-nil, the function that implements the current input method.
12511 It's called with one argument, a printing character that was just read.
12512 \(That means a character with code 040...0176.)
12513 Typically this function uses `read-event' to read additional events.
12514 When it does so, it should first bind `input-method-function' to nil
12515 so it will not be called recursively.
12517 The function should return a list of zero or more events
12518 to be used as input. If it wants to put back some events
12519 to be reconsidered, separately, by the input method,
12520 it can add them to the beginning of `unread-command-events'.
12522 The input method function can find in `input-method-previous-message'
12523 the previous echo area message.
12525 The input method function should refer to the variables
12526 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12527 for guidance on what to do. */);
12528 Vinput_method_function = Qnil;
12530 DEFVAR_LISP ("input-method-previous-message",
12531 &Vinput_method_previous_message,
12532 doc: /* When `input-method-function' is called, hold the previous echo area message.
12533 This variable exists because `read-event' clears the echo area
12534 before running the input method. It is nil if there was no message. */);
12535 Vinput_method_previous_message = Qnil;
12537 DEFVAR_LISP ("show-help-function", &Vshow_help_function,
12538 doc: /* If non-nil, the function that implements the display of help.
12539 It's called with one argument, the help string to display. */);
12540 Vshow_help_function = Qnil;
12542 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment,
12543 doc: /* If non-nil, suppress point adjustment after executing a command.
12545 After a command is executed, if point is moved into a region that has
12546 special properties (e.g. composition, display), we adjust point to
12547 the boundary of the region. But, when a command sets this variable to
12548 non-nil, we suppress the point adjustment.
12550 This variable is set to nil before reading a command, and is checked
12551 just after executing the command. */);
12552 Vdisable_point_adjustment = Qnil;
12554 DEFVAR_LISP ("global-disable-point-adjustment",
12555 &Vglobal_disable_point_adjustment,
12556 doc: /* *If non-nil, always suppress point adjustment.
12558 The default value is nil, in which case, point adjustment are
12559 suppressed only after special commands that set
12560 `disable-point-adjustment' (which see) to non-nil. */);
12561 Vglobal_disable_point_adjustment = Qnil;
12563 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout,
12564 doc: /* *How long to display an echo-area message when the minibuffer is active.
12565 If the value is not a number, such messages don't time out. */);
12566 Vminibuffer_message_timeout = make_number (2);
12568 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input,
12569 doc: /* If non-nil, any keyboard input throws to this symbol.
12570 The value of that variable is passed to `quit-flag' and later causes a
12571 peculiar kind of quitting. */);
12572 Vthrow_on_input = Qnil;
12574 DEFVAR_LISP ("command-error-function", &Vcommand_error_function,
12575 doc: /* If non-nil, function to output error messages.
12576 The arguments are the error data, a list of the form
12577 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12578 such as just as `condition-case' would bind its variable to,
12579 the context (a string which normally goes at the start of the message),
12580 and the Lisp function within which the error was signaled. */);
12581 Vcommand_error_function = Qnil;
12583 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12584 &Venable_disabled_menus_and_buttons,
12585 doc: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12587 Help functions bind this to allow help on disabled menu items
12588 and tool-bar buttons. */);
12589 Venable_disabled_menus_and_buttons = Qnil;
12591 /* Create the initial keyboard. */
12592 initial_kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
12593 init_kboard (initial_kboard);
12594 /* Vwindow_system is left at t for now. */
12595 initial_kboard->next_kboard = all_kboards;
12596 all_kboards = initial_kboard;
12599 void
12600 keys_of_keyboard ()
12602 initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
12603 initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
12604 initial_define_key (meta_map, Ctl ('C'), "exit-recursive-edit");
12605 initial_define_key (global_map, Ctl (']'), "abort-recursive-edit");
12606 initial_define_key (meta_map, 'x', "execute-extended-command");
12608 initial_define_lispy_key (Vspecial_event_map, "delete-frame",
12609 "handle-delete-frame");
12610 initial_define_lispy_key (Vspecial_event_map, "ns-put-working-text",
12611 "ns-put-working-text");
12612 initial_define_lispy_key (Vspecial_event_map, "ns-unput-working-text",
12613 "ns-unput-working-text");
12614 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12615 current-prefix-arg, as is done in `handle-switch-frame'.
12616 But `handle-switch-frame is not run from the special-map.
12617 Commands from that map are run in a special way that automatically
12618 preserves the prefix-arg. Restoring the prefix arg here is not just
12619 redundant but harmful:
12620 - C-u C-x v =
12621 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12622 - after the first prompt, the exit-minibuffer-hook is run which may
12623 iconify a frame and thus push a `iconify-frame' event.
12624 - after running exit-minibuffer-hook, current-prefix-arg is
12625 restored to the non-nil value it had before the prompt.
12626 - we enter the second prompt.
12627 current-prefix-arg is non-nil, prefix-arg is nil.
12628 - before running the first real event, we run the special iconify-frame
12629 event, but we pass the `special' arg to execute-command so
12630 current-prefix-arg and prefix-arg are left untouched.
12631 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12632 - the next key event will have a spuriously non-nil current-prefix-arg. */
12633 initial_define_lispy_key (Vspecial_event_map, "iconify-frame",
12634 "ignore");
12635 initial_define_lispy_key (Vspecial_event_map, "make-frame-visible",
12636 "ignore");
12637 /* Handling it at such a low-level causes read_key_sequence to get
12638 * confused because it doesn't realize that the current_buffer was
12639 * changed by read_char.
12641 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12642 * "handle-select-window"); */
12643 initial_define_lispy_key (Vspecial_event_map, "save-session",
12644 "handle-save-session");
12646 #ifdef HAVE_DBUS
12647 /* Define a special event which is raised for dbus callback
12648 functions. */
12649 initial_define_lispy_key (Vspecial_event_map, "dbus-event",
12650 "dbus-handle-event");
12651 #endif
12653 initial_define_lispy_key (Vspecial_event_map, "config-changed-event",
12654 "ignore");
12657 /* Mark the pointers in the kboard objects.
12658 Called by the Fgarbage_collector. */
12659 void
12660 mark_kboards ()
12662 KBOARD *kb;
12663 Lisp_Object *p;
12664 for (kb = all_kboards; kb; kb = kb->next_kboard)
12666 if (kb->kbd_macro_buffer)
12667 for (p = kb->kbd_macro_buffer; p < kb->kbd_macro_ptr; p++)
12668 mark_object (*p);
12669 mark_object (kb->Voverriding_terminal_local_map);
12670 mark_object (kb->Vlast_command);
12671 mark_object (kb->Vreal_last_command);
12672 mark_object (kb->Vkeyboard_translate_table);
12673 mark_object (kb->Vlast_repeatable_command);
12674 mark_object (kb->Vprefix_arg);
12675 mark_object (kb->Vlast_prefix_arg);
12676 mark_object (kb->kbd_queue);
12677 mark_object (kb->defining_kbd_macro);
12678 mark_object (kb->Vlast_kbd_macro);
12679 mark_object (kb->Vsystem_key_alist);
12680 mark_object (kb->system_key_syms);
12681 mark_object (kb->Vwindow_system);
12682 mark_object (kb->Vinput_decode_map);
12683 mark_object (kb->Vlocal_function_key_map);
12684 mark_object (kb->Vdefault_minibuffer_frame);
12685 mark_object (kb->echo_string);
12688 struct input_event *event;
12689 for (event = kbd_fetch_ptr; event != kbd_store_ptr; event++)
12691 if (event == kbd_buffer + KBD_BUFFER_SIZE)
12692 event = kbd_buffer;
12693 if (event->kind != SELECTION_REQUEST_EVENT
12694 && event->kind != SELECTION_CLEAR_EVENT)
12696 mark_object (event->x);
12697 mark_object (event->y);
12699 mark_object (event->frame_or_window);
12700 mark_object (event->arg);
12705 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
12706 (do not change this comment) */