(Fdefvar): Doc fix.
[emacs.git] / src / keyboard.c
blob4d48c22f30e4fb11dec12d203b3b8e44b6a59906
1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 #include <config.h>
23 #include <signal.h>
24 #include <stdio.h>
25 #include "termchar.h"
26 #include "termopts.h"
27 #include "lisp.h"
28 #include "termhooks.h"
29 #include "macros.h"
30 #include "frame.h"
31 #include "window.h"
32 #include "commands.h"
33 #include "buffer.h"
34 #include "charset.h"
35 #include "disptab.h"
36 #include "dispextern.h"
37 #include "keyboard.h"
38 #include "syntax.h"
39 #include "intervals.h"
40 #include "blockinput.h"
41 #include "puresize.h"
42 #include "systime.h"
43 #include "atimer.h"
44 #include <setjmp.h>
45 #include <errno.h>
47 #ifdef MSDOS
48 #include "msdos.h"
49 #include <time.h>
50 #else /* not MSDOS */
51 #ifndef VMS
52 #include <sys/ioctl.h>
53 #endif
54 #endif /* not MSDOS */
56 #include "syssignal.h"
57 #include "systty.h"
59 #include <sys/types.h>
60 #ifdef HAVE_UNISTD_H
61 #include <unistd.h>
62 #endif
64 /* This is to get the definitions of the XK_ symbols. */
65 #ifdef HAVE_X_WINDOWS
66 #include "xterm.h"
67 #endif
69 #ifdef HAVE_NTGUI
70 #include "w32term.h"
71 #endif /* HAVE_NTGUI */
73 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
74 #include "systime.h"
76 extern int errno;
78 /* Variables for blockinput.h: */
80 /* Non-zero if interrupt input is blocked right now. */
81 int interrupt_input_blocked;
83 /* Nonzero means an input interrupt has arrived
84 during the current critical section. */
85 int interrupt_input_pending;
88 /* File descriptor to use for input. */
89 extern int input_fd;
91 #ifdef HAVE_WINDOW_SYSTEM
92 /* Make all keyboard buffers much bigger when using X windows. */
93 #ifdef macintosh
94 /* But not too big (local data > 32K error) if on macintosh */
95 #define KBD_BUFFER_SIZE 512
96 #else
97 #define KBD_BUFFER_SIZE 4096
98 #endif
99 #else /* No X-windows, character input */
100 #define KBD_BUFFER_SIZE 256
101 #endif /* No X-windows */
103 /* Following definition copied from eval.c */
105 struct backtrace
107 struct backtrace *next;
108 Lisp_Object *function;
109 Lisp_Object *args; /* Points to vector of args. */
110 int nargs; /* length of vector. If nargs is UNEVALLED,
111 args points to slot holding list of
112 unevalled args */
113 char evalargs;
116 #ifdef MULTI_KBOARD
117 KBOARD *initial_kboard;
118 KBOARD *current_kboard;
119 KBOARD *all_kboards;
120 int single_kboard;
121 #else
122 KBOARD the_only_kboard;
123 #endif
125 /* Non-nil disable property on a command means
126 do not execute it; call disabled-command-hook's value instead. */
127 Lisp_Object Qdisabled, Qdisabled_command_hook;
129 #define NUM_RECENT_KEYS (100)
130 int recent_keys_index; /* Index for storing next element into recent_keys */
131 int total_keys; /* Total number of elements stored into recent_keys */
132 Lisp_Object recent_keys; /* A vector, holding the last 100 keystrokes */
134 /* Vector holding the key sequence that invoked the current command.
135 It is reused for each command, and it may be longer than the current
136 sequence; this_command_key_count indicates how many elements
137 actually mean something.
138 It's easier to staticpro a single Lisp_Object than an array. */
139 Lisp_Object this_command_keys;
140 int this_command_key_count;
142 /* This vector is used as a buffer to record the events that were actually read
143 by read_key_sequence. */
144 Lisp_Object raw_keybuf;
145 int raw_keybuf_count;
147 #define GROW_RAW_KEYBUF \
148 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
150 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
151 Lisp_Object new; \
152 new = Fmake_vector (make_number (newsize), Qnil); \
153 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
154 raw_keybuf_count * sizeof (Lisp_Object)); \
155 raw_keybuf = new; \
158 /* Number of elements of this_command_keys
159 that precede this key sequence. */
160 int this_single_command_key_start;
162 /* Record values of this_command_key_count and echo_length ()
163 before this command was read. */
164 static int before_command_key_count;
165 static int before_command_echo_length;
166 /* Values of before_command_key_count and before_command_echo_length
167 saved by reset-this-command-lengths. */
168 static int before_command_key_count_1;
169 static int before_command_echo_length_1;
170 /* Flag set by reset-this-command-lengths,
171 saying to reset the lengths when add_command_key is called. */
172 static int before_command_restore_flag;
174 extern int minbuf_level;
176 extern int message_enable_multibyte;
178 extern struct backtrace *backtrace_list;
180 /* If non-nil, the function that implements the display of help.
181 It's called with one argument, the help string to display. */
183 Lisp_Object Vshow_help_function;
185 /* Nonzero means do menu prompting. */
186 static int menu_prompting;
188 /* Character to see next line of menu prompt. */
189 static Lisp_Object menu_prompt_more_char;
191 /* For longjmp to where kbd input is being done. */
192 static jmp_buf getcjmp;
194 /* True while doing kbd input. */
195 int waiting_for_input;
197 /* True while displaying for echoing. Delays C-g throwing. */
199 static int echoing;
201 /* Non-null means we can start echoing at the next input pause even
202 though there is something in the echo area. */
204 static struct kboard *ok_to_echo_at_next_pause;
206 /* The kboard last echoing, or null for none. Reset to 0 in
207 cancel_echoing. If non-null, and a current echo area message
208 exists, and echo_message_buffer is eq to the current message
209 buffer, we know that the message comes from echo_kboard. */
211 static struct kboard *echo_kboard;
213 /* The buffer used for echoing. Set in echo_now, reset in
214 cancel_echoing. */
216 static Lisp_Object echo_message_buffer;
218 /* Nonzero means disregard local maps for the menu bar. */
219 static int inhibit_local_menu_bar_menus;
221 /* Nonzero means C-g should cause immediate error-signal. */
222 int immediate_quit;
224 /* The user's ERASE setting. */
225 Lisp_Object Vtty_erase_char;
227 /* Character to recognize as the help char. */
228 Lisp_Object Vhelp_char;
230 /* List of other event types to recognize as meaning "help". */
231 Lisp_Object Vhelp_event_list;
233 /* Form to execute when help char is typed. */
234 Lisp_Object Vhelp_form;
236 /* Command to run when the help character follows a prefix key. */
237 Lisp_Object Vprefix_help_command;
239 /* List of items that should move to the end of the menu bar. */
240 Lisp_Object Vmenu_bar_final_items;
242 /* Non-nil means show the equivalent key-binding for
243 any M-x command that has one.
244 The value can be a length of time to show the message for.
245 If the value is non-nil and not a number, we wait 2 seconds. */
246 Lisp_Object Vsuggest_key_bindings;
248 /* Character that causes a quit. Normally C-g.
250 If we are running on an ordinary terminal, this must be an ordinary
251 ASCII char, since we want to make it our interrupt character.
253 If we are not running on an ordinary terminal, it still needs to be
254 an ordinary ASCII char. This character needs to be recognized in
255 the input interrupt handler. At this point, the keystroke is
256 represented as a struct input_event, while the desired quit
257 character is specified as a lispy event. The mapping from struct
258 input_events to lispy events cannot run in an interrupt handler,
259 and the reverse mapping is difficult for anything but ASCII
260 keystrokes.
262 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
263 ASCII character. */
264 int quit_char;
266 extern Lisp_Object current_global_map;
267 extern int minibuf_level;
269 /* If non-nil, this is a map that overrides all other local maps. */
270 Lisp_Object Voverriding_local_map;
272 /* If non-nil, Voverriding_local_map applies to the menu bar. */
273 Lisp_Object Voverriding_local_map_menu_flag;
275 /* Keymap that defines special misc events that should
276 be processed immediately at a low level. */
277 Lisp_Object Vspecial_event_map;
279 /* Current depth in recursive edits. */
280 int command_loop_level;
282 /* Total number of times command_loop has read a key sequence. */
283 int num_input_keys;
285 /* Last input character read as a command. */
286 Lisp_Object last_command_char;
288 /* Last input character read as a command, not counting menus
289 reached by the mouse. */
290 Lisp_Object last_nonmenu_event;
292 /* Last input character read for any purpose. */
293 Lisp_Object last_input_char;
295 /* If not Qnil, a list of objects to be read as subsequent command input. */
296 Lisp_Object Vunread_command_events;
298 /* If not Qnil, a list of objects to be read as subsequent command input
299 including input method processing. */
300 Lisp_Object Vunread_input_method_events;
302 /* If not Qnil, a list of objects to be read as subsequent command input
303 but NOT including input method processing. */
304 Lisp_Object Vunread_post_input_method_events;
306 /* If not -1, an event to be read as subsequent command input. */
307 int unread_command_char;
309 /* If not Qnil, this is a switch-frame event which we decided to put
310 off until the end of a key sequence. This should be read as the
311 next command input, after any unread_command_events.
313 read_key_sequence uses this to delay switch-frame events until the
314 end of the key sequence; Fread_char uses it to put off switch-frame
315 events until a non-ASCII event is acceptable as input. */
316 Lisp_Object unread_switch_frame;
318 /* A mask of extra modifier bits to put into every keyboard char. */
319 int extra_keyboard_modifiers;
321 /* Char to use as prefix when a meta character is typed in.
322 This is bound on entry to minibuffer in case ESC is changed there. */
324 Lisp_Object meta_prefix_char;
326 /* Last size recorded for a current buffer which is not a minibuffer. */
327 static int last_non_minibuf_size;
329 /* Number of idle seconds before an auto-save and garbage collection. */
330 static Lisp_Object Vauto_save_timeout;
332 /* Total number of times read_char has returned. */
333 int num_input_events;
335 /* Total number of times read_char has returned, outside of macros. */
336 int num_nonmacro_input_events;
338 /* Auto-save automatically when this many characters have been typed
339 since the last time. */
341 static int auto_save_interval;
343 /* Value of num_nonmacro_input_events as of last auto save. */
345 int last_auto_save;
347 /* The command being executed by the command loop.
348 Commands may set this, and the value set will be copied into
349 current_kboard->Vlast_command instead of the actual command. */
350 Lisp_Object Vthis_command;
352 /* This is like Vthis_command, except that commands never set it. */
353 Lisp_Object real_this_command;
355 /* The value of point when the last command was executed. */
356 int last_point_position;
358 /* The buffer that was current when the last command was started. */
359 Lisp_Object last_point_position_buffer;
361 /* The frame in which the last input event occurred, or Qmacro if the
362 last event came from a macro. We use this to determine when to
363 generate switch-frame events. This may be cleared by functions
364 like Fselect_frame, to make sure that a switch-frame event is
365 generated by the next character. */
366 Lisp_Object internal_last_event_frame;
368 /* A user-visible version of the above, intended to allow users to
369 figure out where the last event came from, if the event doesn't
370 carry that information itself (i.e. if it was a character). */
371 Lisp_Object Vlast_event_frame;
373 /* The timestamp of the last input event we received from the X server.
374 X Windows wants this for selection ownership. */
375 unsigned long last_event_timestamp;
377 Lisp_Object Qself_insert_command;
378 Lisp_Object Qforward_char;
379 Lisp_Object Qbackward_char;
380 Lisp_Object Qundefined;
381 Lisp_Object Qtimer_event_handler;
383 /* read_key_sequence stores here the command definition of the
384 key sequence that it reads. */
385 Lisp_Object read_key_sequence_cmd;
387 /* Echo unfinished commands after this many seconds of pause. */
388 Lisp_Object Vecho_keystrokes;
390 /* Form to evaluate (if non-nil) when Emacs is started. */
391 Lisp_Object Vtop_level;
393 /* User-supplied string to translate input characters through. */
394 Lisp_Object Vkeyboard_translate_table;
396 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
397 extern Lisp_Object Vfunction_key_map;
399 /* Another keymap that maps key sequences into key sequences.
400 This one takes precedence over ordinary definitions. */
401 extern Lisp_Object Vkey_translation_map;
403 /* If non-nil, this implements the current input method. */
404 Lisp_Object Vinput_method_function;
405 Lisp_Object Qinput_method_function;
407 /* When we call Vinput_method_function,
408 this holds the echo area message that was just erased. */
409 Lisp_Object Vinput_method_previous_message;
411 /* Non-nil means deactivate the mark at end of this command. */
412 Lisp_Object Vdeactivate_mark;
414 /* Menu bar specified in Lucid Emacs fashion. */
416 Lisp_Object Vlucid_menu_bar_dirty_flag;
417 Lisp_Object Qrecompute_lucid_menubar, Qactivate_menubar_hook;
419 Lisp_Object Qecho_area_clear_hook;
421 /* Hooks to run before and after each command. */
422 Lisp_Object Qpre_command_hook, Vpre_command_hook;
423 Lisp_Object Qpost_command_hook, Vpost_command_hook;
424 Lisp_Object Qcommand_hook_internal, Vcommand_hook_internal;
425 /* Hook run after a command if there's no more input soon. */
426 Lisp_Object Qpost_command_idle_hook, Vpost_command_idle_hook;
428 /* Delay time in microseconds before running post-command-idle-hook. */
429 int post_command_idle_delay;
431 /* List of deferred actions to be performed at a later time.
432 The precise format isn't relevant here; we just check whether it is nil. */
433 Lisp_Object Vdeferred_action_list;
435 /* Function to call to handle deferred actions, when there are any. */
436 Lisp_Object Vdeferred_action_function;
437 Lisp_Object Qdeferred_action_function;
439 Lisp_Object Qinput_method_exit_on_first_char;
440 Lisp_Object Qinput_method_use_echo_area;
442 /* File in which we write all commands we read. */
443 FILE *dribble;
445 /* Nonzero if input is available. */
446 int input_pending;
448 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
449 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
451 int meta_key;
453 extern char *pending_malloc_warning;
455 /* Circular buffer for pre-read keyboard input. */
457 static struct input_event kbd_buffer[KBD_BUFFER_SIZE];
459 /* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
461 The interrupt-level event handlers will never enqueue an event on a
462 frame which is not in Vframe_list, and once an event is dequeued,
463 internal_last_event_frame or the event itself points to the frame.
464 So that's all fine.
466 But while the event is sitting in the queue, it's completely
467 unprotected. Suppose the user types one command which will run for
468 a while and then delete a frame, and then types another event at
469 the frame that will be deleted, before the command gets around to
470 it. Suppose there are no references to this frame elsewhere in
471 Emacs, and a GC occurs before the second event is dequeued. Now we
472 have an event referring to a freed frame, which will crash Emacs
473 when it is dequeued.
475 Similar things happen when an event on a scroll bar is enqueued; the
476 window may be deleted while the event is in the queue.
478 So, we use this vector to protect the Lisp_Objects in the event
479 queue. That way, they'll be dequeued as dead frames or windows,
480 but still valid Lisp objects.
482 If kbd_buffer[i].kind != no_event, then
484 AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
485 AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
487 static Lisp_Object kbd_buffer_gcpro;
489 /* Pointer to next available character in kbd_buffer.
490 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
491 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the the
492 next available char is in kbd_buffer[0]. */
493 static struct input_event *kbd_fetch_ptr;
495 /* Pointer to next place to store character in kbd_buffer. This
496 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
497 character should go in kbd_buffer[0]. */
498 static struct input_event * volatile kbd_store_ptr;
500 /* The above pair of variables forms a "queue empty" flag. When we
501 enqueue a non-hook event, we increment kbd_store_ptr. When we
502 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
503 there is input available iff the two pointers are not equal.
505 Why not just have a flag set and cleared by the enqueuing and
506 dequeuing functions? Such a flag could be screwed up by interrupts
507 at inopportune times. */
509 /* If this flag is non-nil, we check mouse_moved to see when the
510 mouse moves, and motion events will appear in the input stream.
511 Otherwise, mouse motion is ignored. */
512 static Lisp_Object do_mouse_tracking;
514 /* Symbols to head events. */
515 Lisp_Object Qmouse_movement;
516 Lisp_Object Qscroll_bar_movement;
517 Lisp_Object Qswitch_frame;
518 Lisp_Object Qdelete_frame;
519 Lisp_Object Qiconify_frame;
520 Lisp_Object Qmake_frame_visible;
521 Lisp_Object Qhelp_echo;
523 /* Symbols to denote kinds of events. */
524 Lisp_Object Qfunction_key;
525 Lisp_Object Qmouse_click;
526 #ifdef WINDOWSNT
527 Lisp_Object Qmouse_wheel;
528 Lisp_Object Qlanguage_change;
529 #endif
530 Lisp_Object Qdrag_n_drop;
531 /* Lisp_Object Qmouse_movement; - also an event header */
533 /* Properties of event headers. */
534 Lisp_Object Qevent_kind;
535 Lisp_Object Qevent_symbol_elements;
537 /* menu item parts */
538 Lisp_Object Qmenu_alias;
539 Lisp_Object Qmenu_enable;
540 Lisp_Object QCenable, QCvisible, QChelp, QCfilter, QCkeys, QCkey_sequence;
541 Lisp_Object QCbutton, QCtoggle, QCradio;
542 extern Lisp_Object Vdefine_key_rebound_commands;
543 extern Lisp_Object Qmenu_item;
545 /* An event header symbol HEAD may have a property named
546 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
547 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
548 mask of modifiers applied to it. If present, this is used to help
549 speed up parse_modifiers. */
550 Lisp_Object Qevent_symbol_element_mask;
552 /* An unmodified event header BASE may have a property named
553 Qmodifier_cache, which is an alist mapping modifier masks onto
554 modified versions of BASE. If present, this helps speed up
555 apply_modifiers. */
556 Lisp_Object Qmodifier_cache;
558 /* Symbols to use for parts of windows. */
559 Lisp_Object Qmode_line;
560 Lisp_Object Qvertical_line;
561 Lisp_Object Qvertical_scroll_bar;
562 Lisp_Object Qmenu_bar;
564 Lisp_Object recursive_edit_unwind (), command_loop ();
565 Lisp_Object Fthis_command_keys ();
566 Lisp_Object Qextended_command_history;
567 EMACS_TIME timer_check ();
569 extern Lisp_Object Vhistory_length;
571 extern char *x_get_keysym_name ();
573 static void record_menu_key ();
575 Lisp_Object Qpolling_period;
577 /* List of absolute timers. Appears in order of next scheduled event. */
578 Lisp_Object Vtimer_list;
580 /* List of idle time timers. Appears in order of next scheduled event. */
581 Lisp_Object Vtimer_idle_list;
583 /* Incremented whenever a timer is run. */
584 int timers_run;
586 extern Lisp_Object Vprint_level, Vprint_length;
588 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
589 happens. */
590 EMACS_TIME *input_available_clear_time;
592 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
593 Default is 1 if INTERRUPT_INPUT is defined. */
594 int interrupt_input;
596 /* Nonzero while interrupts are temporarily deferred during redisplay. */
597 int interrupts_deferred;
599 /* Nonzero means use ^S/^Q for flow control. */
600 int flow_control;
602 /* Allow m- file to inhibit use of FIONREAD. */
603 #ifdef BROKEN_FIONREAD
604 #undef FIONREAD
605 #endif
607 /* We are unable to use interrupts if FIONREAD is not available,
608 so flush SIGIO so we won't try. */
609 #ifndef FIONREAD
610 #ifdef SIGIO
611 #undef SIGIO
612 #endif
613 #endif
615 /* If we support a window system, turn on the code to poll periodically
616 to detect C-g. It isn't actually used when doing interrupt input. */
617 #ifdef HAVE_WINDOW_SYSTEM
618 #define POLL_FOR_INPUT
619 #endif
621 /* After a command is executed, if point is moved into a region that
622 has specific properties (e.g. composition, display), we adjust
623 point to the boundary of the region. But, if a command sets this
624 valiable to non-nil, we suppress this point adjustment. This
625 variable is set to nil before reading a command. */
627 Lisp_Object Vdisable_point_adjustment;
629 /* If non-nil, always disable point adjustment. */
631 Lisp_Object Vglobal_disable_point_adjustment;
634 /* Global variable declarations. */
636 /* Function for init_keyboard to call with no args (if nonzero). */
637 void (*keyboard_init_hook) ();
639 static int read_avail_input ();
640 static void get_input_pending ();
641 static int readable_events ();
642 static Lisp_Object read_char_x_menu_prompt ();
643 static Lisp_Object read_char_minibuf_menu_prompt ();
644 static Lisp_Object make_lispy_event ();
645 #ifdef HAVE_MOUSE
646 static Lisp_Object make_lispy_movement ();
647 #endif
648 static Lisp_Object modify_event_symbol ();
649 static Lisp_Object make_lispy_switch_frame ();
650 static int parse_solitary_modifier ();
651 static void save_getcjmp ();
652 static void restore_getcjmp ();
653 static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
655 /* Nonzero means don't try to suspend even if the operating system seems
656 to support it. */
657 static int cannot_suspend;
659 #define min(a,b) ((a)<(b)?(a):(b))
660 #define max(a,b) ((a)>(b)?(a):(b))
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 char *str;
670 int len = strlen (str);
672 if (len > ECHOBUFSIZE - 4)
673 len = ECHOBUFSIZE - 4;
674 bcopy (str, current_kboard->echobuf, len);
675 current_kboard->echoptr = current_kboard->echobuf + len;
676 *current_kboard->echoptr = '\0';
678 current_kboard->echo_after_prompt = len;
680 echo_now ();
683 /* Add C to the echo string, if echoing is going on.
684 C can be a character, which is printed prettily ("M-C-x" and all that
685 jazz), or a symbol, whose name is printed. */
687 void
688 echo_char (c)
689 Lisp_Object c;
691 extern char *push_key_description ();
693 if (current_kboard->immediate_echo)
695 char *ptr = current_kboard->echoptr;
697 if (ptr != current_kboard->echobuf)
698 *ptr++ = ' ';
700 /* If someone has passed us a composite event, use its head symbol. */
701 c = EVENT_HEAD (c);
703 if (INTEGERP (c))
705 if (ptr - current_kboard->echobuf
706 > ECHOBUFSIZE - KEY_DESCRIPTION_SIZE)
707 return;
709 ptr = push_key_description (XINT (c), ptr);
711 else if (SYMBOLP (c))
713 struct Lisp_String *name = XSYMBOL (c)->name;
714 if ((ptr - current_kboard->echobuf) + STRING_BYTES (name) + 4
715 > ECHOBUFSIZE)
716 return;
717 bcopy (name->data, ptr, STRING_BYTES (name));
718 ptr += STRING_BYTES (name);
721 if (current_kboard->echoptr == current_kboard->echobuf
722 && help_char_p (c))
724 strcpy (ptr, " (Type ? for further options)");
725 ptr += strlen (ptr);
728 *ptr = 0;
729 current_kboard->echoptr = ptr;
731 echo_now ();
735 /* Temporarily add a dash to the end of the echo string if it's not
736 empty, so that it serves as a mini-prompt for the very next character. */
738 void
739 echo_dash ()
741 if (!current_kboard->immediate_echo
742 && current_kboard->echoptr == current_kboard->echobuf)
743 return;
744 /* Do nothing if we just printed a prompt. */
745 if (current_kboard->echo_after_prompt
746 == current_kboard->echoptr - current_kboard->echobuf)
747 return;
748 /* Do nothing if not echoing at all. */
749 if (current_kboard->echoptr == 0)
750 return;
752 /* Put a dash at the end of the buffer temporarily,
753 but make it go away when the next character is added. */
754 current_kboard->echoptr[0] = '-';
755 current_kboard->echoptr[1] = 0;
757 echo_now ();
760 /* Display the current echo string, and begin echoing if not already
761 doing so. */
763 void
764 echo_now ()
766 if (!current_kboard->immediate_echo)
768 int i;
769 current_kboard->immediate_echo = 1;
771 for (i = 0; i < this_command_key_count; i++)
773 Lisp_Object c;
774 c = XVECTOR (this_command_keys)->contents[i];
775 if (! (EVENT_HAS_PARAMETERS (c)
776 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
777 echo_char (c);
779 echo_dash ();
782 echoing = 1;
783 message2_nolog (current_kboard->echobuf, strlen (current_kboard->echobuf),
784 ! NILP (current_buffer->enable_multibyte_characters));
785 echoing = 0;
787 /* Record in what buffer we echoed, and from which kboard. */
788 echo_message_buffer = echo_area_buffer[0];
789 echo_kboard = current_kboard;
791 if (waiting_for_input && !NILP (Vquit_flag))
792 quit_throw_to_read_char ();
795 /* Turn off echoing, for the start of a new command. */
797 void
798 cancel_echoing ()
800 current_kboard->immediate_echo = 0;
801 current_kboard->echoptr = current_kboard->echobuf;
802 current_kboard->echo_after_prompt = -1;
803 ok_to_echo_at_next_pause = NULL;
804 echo_kboard = NULL;
805 echo_message_buffer = Qnil;
808 /* Return the length of the current echo string. */
810 static int
811 echo_length ()
813 return current_kboard->echoptr - current_kboard->echobuf;
816 /* Truncate the current echo message to its first LEN chars.
817 This and echo_char get used by read_key_sequence when the user
818 switches frames while entering a key sequence. */
820 static void
821 echo_truncate (len)
822 int len;
824 current_kboard->echobuf[len] = '\0';
825 current_kboard->echoptr = current_kboard->echobuf + len;
826 truncate_echo_area (len);
830 /* Functions for manipulating this_command_keys. */
831 static void
832 add_command_key (key)
833 Lisp_Object key;
835 int size = XVECTOR (this_command_keys)->size;
837 /* If reset-this-command-length was called recently, obey it now.
838 See the doc string of that function for an explanation of why. */
839 if (before_command_restore_flag)
841 this_command_key_count = before_command_key_count_1;
842 if (this_command_key_count < this_single_command_key_start)
843 this_single_command_key_start = this_command_key_count;
844 echo_truncate (before_command_echo_length_1);
845 before_command_restore_flag = 0;
848 if (this_command_key_count >= size)
850 Lisp_Object new_keys;
852 new_keys = Fmake_vector (make_number (size * 2), Qnil);
853 bcopy (XVECTOR (this_command_keys)->contents,
854 XVECTOR (new_keys)->contents,
855 size * sizeof (Lisp_Object));
857 this_command_keys = new_keys;
860 XVECTOR (this_command_keys)->contents[this_command_key_count++] = key;
863 Lisp_Object
864 recursive_edit_1 ()
866 int count = specpdl_ptr - specpdl;
867 Lisp_Object val;
869 if (command_loop_level > 0)
871 specbind (Qstandard_output, Qt);
872 specbind (Qstandard_input, Qt);
875 #ifdef HAVE_X_WINDOWS
876 /* The command loop has started a busy-cursor timer, so we have to
877 cancel it here, otherwise it will fire because the recursive edit
878 can take some time. */
879 if (display_busy_cursor_p)
880 cancel_busy_cursor ();
881 #endif
883 val = command_loop ();
884 if (EQ (val, Qt))
885 Fsignal (Qquit, Qnil);
886 /* Handle throw from read_minibuf when using minibuffer
887 while it's active but we're in another window. */
888 if (STRINGP (val))
889 Fsignal (Qerror, Fcons (val, Qnil));
891 return unbind_to (count, Qnil);
894 /* When an auto-save happens, record the "time", and don't do again soon. */
896 void
897 record_auto_save ()
899 last_auto_save = num_nonmacro_input_events;
902 /* Make an auto save happen as soon as possible at command level. */
904 void
905 force_auto_save_soon ()
907 last_auto_save = - auto_save_interval - 1;
909 record_asynch_buffer_change ();
912 DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
913 "Invoke the editor command loop recursively.\n\
914 To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
915 that tells this function to return.\n\
916 Alternately, `(throw 'exit t)' makes this function signal an error.\n\
917 This function is called by the editor initialization to begin editing.")
920 int count = specpdl_ptr - specpdl;
922 command_loop_level++;
923 update_mode_lines = 1;
925 record_unwind_protect (recursive_edit_unwind,
926 (command_loop_level
927 && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
928 ? Fcurrent_buffer ()
929 : Qnil);
930 recursive_edit_1 ();
931 return unbind_to (count, Qnil);
934 Lisp_Object
935 recursive_edit_unwind (buffer)
936 Lisp_Object buffer;
938 if (!NILP (buffer))
939 Fset_buffer (buffer);
941 command_loop_level--;
942 update_mode_lines = 1;
943 return Qnil;
946 static void
947 any_kboard_state ()
949 #ifdef MULTI_KBOARD
950 #if 0 /* Theory: if there's anything in Vunread_command_events,
951 it will right away be read by read_key_sequence,
952 and then if we do switch KBOARDS, it will go into the side
953 queue then. So we don't need to do anything special here -- rms. */
954 if (CONSP (Vunread_command_events))
956 current_kboard->kbd_queue
957 = nconc2 (Vunread_command_events, current_kboard->kbd_queue);
958 current_kboard->kbd_queue_has_data = 1;
960 Vunread_command_events = Qnil;
961 #endif
962 single_kboard = 0;
963 #endif
966 /* Switch to the single-kboard state, making current_kboard
967 the only KBOARD from which further input is accepted. */
969 void
970 single_kboard_state ()
972 #ifdef MULTI_KBOARD
973 single_kboard = 1;
974 #endif
977 /* Maintain a stack of kboards, so other parts of Emacs
978 can switch temporarily to the kboard of a given frame
979 and then revert to the previous status. */
981 struct kboard_stack
983 KBOARD *kboard;
984 struct kboard_stack *next;
987 static struct kboard_stack *kboard_stack;
989 void
990 push_frame_kboard (f)
991 FRAME_PTR f;
993 #ifdef MULTI_KBOARD
994 struct kboard_stack *p
995 = (struct kboard_stack *) xmalloc (sizeof (struct kboard_stack));
997 p->next = kboard_stack;
998 p->kboard = current_kboard;
999 kboard_stack = p;
1001 current_kboard = FRAME_KBOARD (f);
1002 #endif
1005 void
1006 pop_frame_kboard ()
1008 #ifdef MULTI_KBOARD
1009 struct kboard_stack *p = kboard_stack;
1010 current_kboard = p->kboard;
1011 kboard_stack = p->next;
1012 xfree (p);
1013 #endif
1016 /* Handle errors that are not handled at inner levels
1017 by printing an error message and returning to the editor command loop. */
1019 Lisp_Object
1020 cmd_error (data)
1021 Lisp_Object data;
1023 Lisp_Object old_level, old_length;
1024 char macroerror[50];
1026 if (!NILP (executing_macro))
1028 if (executing_macro_iterations == 1)
1029 sprintf (macroerror, "After 1 kbd macro iteration: ");
1030 else
1031 sprintf (macroerror, "After %d kbd macro iterations: ",
1032 executing_macro_iterations);
1034 else
1035 *macroerror = 0;
1037 Vstandard_output = Qt;
1038 Vstandard_input = Qt;
1039 Vexecuting_macro = Qnil;
1040 executing_macro = Qnil;
1041 current_kboard->Vprefix_arg = Qnil;
1042 current_kboard->Vlast_prefix_arg = Qnil;
1043 cancel_echoing ();
1045 /* Avoid unquittable loop if data contains a circular list. */
1046 old_level = Vprint_level;
1047 old_length = Vprint_length;
1048 XSETFASTINT (Vprint_level, 10);
1049 XSETFASTINT (Vprint_length, 10);
1050 cmd_error_internal (data, macroerror);
1051 Vprint_level = old_level;
1052 Vprint_length = old_length;
1054 Vquit_flag = Qnil;
1056 Vinhibit_quit = Qnil;
1057 #ifdef MULTI_KBOARD
1058 any_kboard_state ();
1059 #endif
1061 return make_number (0);
1064 /* Take actions on handling an error. DATA is the data that describes
1065 the error.
1067 CONTEXT is a C-string containing ASCII characters only which
1068 describes the context in which the error happened. If we need to
1069 generalize CONTEXT to allow multibyte characters, make it a Lisp
1070 string. */
1072 void
1073 cmd_error_internal (data, context)
1074 Lisp_Object data;
1075 char *context;
1077 Lisp_Object stream;
1078 int kill_emacs_p = 0;
1079 struct frame *sf = SELECTED_FRAME ();
1081 Vquit_flag = Qnil;
1082 Vinhibit_quit = Qt;
1083 clear_message (1, 0);
1085 /* If the window system or terminal frame hasn't been initialized
1086 yet, or we're not interactive, it's best to dump this message out
1087 to stderr and exit. */
1088 if (!sf->glyphs_initialized_p
1089 /* This is the case of the frame dumped with Emacs, when we're
1090 running under a window system. */
1091 || (!NILP (Vwindow_system)
1092 && !inhibit_window_system
1093 && FRAME_TERMCAP_P (sf))
1094 || noninteractive)
1096 stream = Qexternal_debugging_output;
1097 kill_emacs_p = 1;
1099 else
1101 Fdiscard_input ();
1102 bitch_at_user ();
1103 stream = Qt;
1106 if (context != 0)
1107 write_string_1 (context, -1, stream);
1109 print_error_message (data, stream);
1111 /* If the window system or terminal frame hasn't been initialized
1112 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1113 if (kill_emacs_p)
1115 Fterpri (stream);
1116 Fkill_emacs (make_number (-1));
1120 Lisp_Object command_loop_1 ();
1121 Lisp_Object command_loop_2 ();
1122 Lisp_Object top_level_1 ();
1124 /* Entry to editor-command-loop.
1125 This level has the catches for exiting/returning to editor command loop.
1126 It returns nil to exit recursive edit, t to abort it. */
1128 Lisp_Object
1129 command_loop ()
1131 if (command_loop_level > 0 || minibuf_level > 0)
1133 Lisp_Object val;
1134 val = internal_catch (Qexit, command_loop_2, Qnil);
1135 executing_macro = Qnil;
1136 return val;
1138 else
1139 while (1)
1141 internal_catch (Qtop_level, top_level_1, Qnil);
1142 internal_catch (Qtop_level, command_loop_2, Qnil);
1143 executing_macro = Qnil;
1145 /* End of file in -batch run causes exit here. */
1146 if (noninteractive)
1147 Fkill_emacs (Qt);
1151 /* Here we catch errors in execution of commands within the
1152 editing loop, and reenter the editing loop.
1153 When there is an error, cmd_error runs and returns a non-nil
1154 value to us. A value of nil means that cmd_loop_1 itself
1155 returned due to end of file (or end of kbd macro). */
1157 Lisp_Object
1158 command_loop_2 ()
1160 register Lisp_Object val;
1163 val = internal_condition_case (command_loop_1, Qerror, cmd_error);
1164 while (!NILP (val));
1166 return Qnil;
1169 Lisp_Object
1170 top_level_2 ()
1172 return Feval (Vtop_level);
1175 Lisp_Object
1176 top_level_1 ()
1178 /* On entry to the outer level, run the startup file */
1179 if (!NILP (Vtop_level))
1180 internal_condition_case (top_level_2, Qerror, cmd_error);
1181 else if (!NILP (Vpurify_flag))
1182 message ("Bare impure Emacs (standard Lisp code not loaded)");
1183 else
1184 message ("Bare Emacs (standard Lisp code not loaded)");
1185 return Qnil;
1188 DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
1189 "Exit all recursive editing levels.")
1192 #ifdef HAVE_X_WINDOWS
1193 if (display_busy_cursor_p)
1194 cancel_busy_cursor ();
1195 #endif
1196 Fthrow (Qtop_level, Qnil);
1199 DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
1200 "Exit from the innermost recursive edit or minibuffer.")
1203 if (command_loop_level > 0 || minibuf_level > 0)
1204 Fthrow (Qexit, Qnil);
1206 error ("No recursive edit is in progress");
1209 DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
1210 "Abort the command that requested this recursive edit or minibuffer input.")
1213 if (command_loop_level > 0 || minibuf_level > 0)
1214 Fthrow (Qexit, Qt);
1216 error ("No recursive edit is in progress");
1219 /* This is the actual command reading loop,
1220 sans error-handling encapsulation. */
1222 Lisp_Object Fcommand_execute ();
1223 static int read_key_sequence ();
1224 void safe_run_hooks ();
1225 static void adjust_point_for_property ();
1227 Lisp_Object
1228 command_loop_1 ()
1230 Lisp_Object cmd;
1231 int lose;
1232 int nonundocount;
1233 Lisp_Object keybuf[30];
1234 int i;
1235 int no_direct;
1236 int prev_modiff;
1237 struct buffer *prev_buffer;
1238 #ifdef MULTI_KBOARD
1239 int was_locked = single_kboard;
1240 #endif
1242 current_kboard->Vprefix_arg = Qnil;
1243 current_kboard->Vlast_prefix_arg = Qnil;
1244 Vdeactivate_mark = Qnil;
1245 waiting_for_input = 0;
1246 cancel_echoing ();
1248 nonundocount = 0;
1249 this_command_key_count = 0;
1250 this_single_command_key_start = 0;
1252 /* Make sure this hook runs after commands that get errors and
1253 throw to top level. */
1254 /* Note that the value cell will never directly contain nil
1255 if the symbol is a local variable. */
1256 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1257 safe_run_hooks (Qpost_command_hook);
1259 /* If displaying a message, resize the echo area window to fit
1260 that message's size exactly. */
1261 if (!NILP (echo_area_buffer[0]))
1262 resize_echo_area_axactly ();
1264 if (!NILP (Vdeferred_action_list))
1265 call0 (Vdeferred_action_function);
1267 if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
1269 if (NILP (Vunread_command_events)
1270 && NILP (Vunread_input_method_events)
1271 && NILP (Vunread_post_input_method_events)
1272 && NILP (Vexecuting_macro)
1273 && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
1274 safe_run_hooks (Qpost_command_idle_hook);
1277 /* Do this after running Vpost_command_hook, for consistency. */
1278 current_kboard->Vlast_command = Vthis_command;
1279 current_kboard->Vreal_last_command = real_this_command;
1281 while (1)
1283 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1284 Fkill_emacs (Qnil);
1286 /* Make sure the current window's buffer is selected. */
1287 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1288 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1290 /* Display any malloc warning that just came out. Use while because
1291 displaying one warning can cause another. */
1293 while (pending_malloc_warning)
1294 display_malloc_warning ();
1296 no_direct = 0;
1298 Vdeactivate_mark = Qnil;
1300 /* If minibuffer on and echo area in use,
1301 wait 2 sec and redraw minibuffer. */
1303 if (minibuf_level
1304 && !NILP (echo_area_buffer[0])
1305 && EQ (minibuf_window, echo_area_window))
1307 /* Bind inhibit-quit to t so that C-g gets read in
1308 rather than quitting back to the minibuffer. */
1309 int count = specpdl_ptr - specpdl;
1310 specbind (Qinhibit_quit, Qt);
1312 Fsit_for (make_number (2), Qnil, Qnil);
1313 /* Clear the echo area. */
1314 message2 (0, 0, 0);
1315 safe_run_hooks (Qecho_area_clear_hook);
1317 unbind_to (count, Qnil);
1319 /* If a C-g came in before, treat it as input now. */
1320 if (!NILP (Vquit_flag))
1322 Vquit_flag = Qnil;
1323 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
1327 #ifdef C_ALLOCA
1328 alloca (0); /* Cause a garbage collection now */
1329 /* Since we can free the most stuff here. */
1330 #endif /* C_ALLOCA */
1332 #if 0
1333 /* Select the frame that the last event came from. Usually,
1334 switch-frame events will take care of this, but if some lisp
1335 code swallows a switch-frame event, we'll fix things up here.
1336 Is this a good idea? */
1337 if (FRAMEP (internal_last_event_frame)
1338 && !EQ (internal_last_event_frame, selected_frame))
1339 Fselect_frame (internal_last_event_frame, Qnil);
1340 #endif
1341 /* If it has changed current-menubar from previous value,
1342 really recompute the menubar from the value. */
1343 if (! NILP (Vlucid_menu_bar_dirty_flag)
1344 && !NILP (Ffboundp (Qrecompute_lucid_menubar)))
1345 call0 (Qrecompute_lucid_menubar);
1347 before_command_key_count = this_command_key_count;
1348 before_command_echo_length = echo_length ();
1350 Vthis_command = Qnil;
1351 real_this_command = Qnil;
1353 /* Read next key sequence; i gets its length. */
1354 i = read_key_sequence (keybuf, sizeof keybuf / sizeof keybuf[0],
1355 Qnil, 0, 1, 1);
1357 /* A filter may have run while we were reading the input. */
1358 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1359 Fkill_emacs (Qnil);
1360 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1361 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1363 ++num_input_keys;
1365 /* Now we have read a key sequence of length I,
1366 or else I is 0 and we found end of file. */
1368 if (i == 0) /* End of file -- happens only in */
1369 return Qnil; /* a kbd macro, at the end. */
1370 /* -1 means read_key_sequence got a menu that was rejected.
1371 Just loop around and read another command. */
1372 if (i == -1)
1374 cancel_echoing ();
1375 this_command_key_count = 0;
1376 this_single_command_key_start = 0;
1377 goto finalize;
1380 last_command_char = keybuf[i - 1];
1382 /* If the previous command tried to force a specific window-start,
1383 forget about that, in case this command moves point far away
1384 from that position. But also throw away beg_unchanged and
1385 end_unchanged information in that case, so that redisplay will
1386 update the whole window properly. */
1387 if (!NILP (XWINDOW (selected_window)->force_start))
1389 struct buffer *b;
1390 XWINDOW (selected_window)->force_start = Qnil;
1391 b = XBUFFER (XWINDOW (selected_window)->buffer);
1392 BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
1395 cmd = read_key_sequence_cmd;
1396 if (!NILP (Vexecuting_macro))
1398 if (!NILP (Vquit_flag))
1400 Vexecuting_macro = Qt;
1401 QUIT; /* Make some noise. */
1402 /* Will return since macro now empty. */
1406 /* Do redisplay processing after this command except in special
1407 cases identified below. */
1408 prev_buffer = current_buffer;
1409 prev_modiff = MODIFF;
1410 last_point_position = PT;
1411 XSETBUFFER (last_point_position_buffer, prev_buffer);
1413 /* By default, we adjust point to a boundary of a region that
1414 has such a property that should be treated intangible
1415 (e.g. composition, display). But, some commands will set
1416 this variable differently. */
1417 Vdisable_point_adjustment = Qnil;
1419 /* Execute the command. */
1421 Vthis_command = cmd;
1422 real_this_command = cmd;
1423 /* Note that the value cell will never directly contain nil
1424 if the symbol is a local variable. */
1425 if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
1426 safe_run_hooks (Qpre_command_hook);
1428 if (NILP (Vthis_command))
1430 /* nil means key is undefined. */
1431 bitch_at_user ();
1432 current_kboard->defining_kbd_macro = Qnil;
1433 update_mode_lines = 1;
1434 current_kboard->Vprefix_arg = Qnil;
1436 else
1438 if (NILP (current_kboard->Vprefix_arg) && ! no_direct)
1440 /* In case we jump to directly_done. */
1441 Vcurrent_prefix_arg = current_kboard->Vprefix_arg;
1443 /* Recognize some common commands in common situations and
1444 do them directly. */
1445 if (EQ (Vthis_command, Qforward_char) && PT < ZV)
1447 struct Lisp_Char_Table *dp
1448 = window_display_table (XWINDOW (selected_window));
1449 lose = FETCH_CHAR (PT_BYTE);
1450 SET_PT (PT + 1);
1451 if ((dp
1452 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1453 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1454 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1455 && (lose >= 0x20 && lose < 0x7f)))
1456 : (lose >= 0x20 && lose < 0x7f))
1457 /* To extract the case of continuation on
1458 wide-column characters. */
1459 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE)) == 1)
1460 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1461 >= MODIFF)
1462 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1463 >= OVERLAY_MODIFF)
1464 && (XFASTINT (XWINDOW (selected_window)->last_point)
1465 == PT - 1)
1466 && !windows_or_buffers_changed
1467 && EQ (current_buffer->selective_display, Qnil)
1468 && !detect_input_pending ()
1469 && NILP (XWINDOW (selected_window)->column_number_displayed)
1470 && NILP (Vexecuting_macro))
1471 direct_output_forward_char (1);
1472 goto directly_done;
1474 else if (EQ (Vthis_command, Qbackward_char) && PT > BEGV)
1476 struct Lisp_Char_Table *dp
1477 = window_display_table (XWINDOW (selected_window));
1478 SET_PT (PT - 1);
1479 lose = FETCH_CHAR (PT_BYTE);
1480 if ((dp
1481 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1482 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1483 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1484 && (lose >= 0x20 && lose < 0x7f)))
1485 : (lose >= 0x20 && lose < 0x7f))
1486 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1487 >= MODIFF)
1488 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1489 >= OVERLAY_MODIFF)
1490 && (XFASTINT (XWINDOW (selected_window)->last_point)
1491 == PT + 1)
1492 && !windows_or_buffers_changed
1493 && EQ (current_buffer->selective_display, Qnil)
1494 && !detect_input_pending ()
1495 && NILP (XWINDOW (selected_window)->column_number_displayed)
1496 && NILP (Vexecuting_macro))
1497 direct_output_forward_char (-1);
1498 goto directly_done;
1500 else if (EQ (Vthis_command, Qself_insert_command)
1501 /* Try this optimization only on ascii keystrokes. */
1502 && INTEGERP (last_command_char))
1504 unsigned int c = XINT (last_command_char);
1505 int value;
1506 if (NILP (Vexecuting_macro)
1507 && !EQ (minibuf_window, selected_window))
1509 if (!nonundocount || nonundocount >= 20)
1511 Fundo_boundary ();
1512 nonundocount = 0;
1514 nonundocount++;
1517 lose = ((XFASTINT (XWINDOW (selected_window)->last_modified)
1518 < MODIFF)
1519 || (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1520 < OVERLAY_MODIFF)
1521 || (XFASTINT (XWINDOW (selected_window)->last_point)
1522 != PT)
1523 || MODIFF <= SAVE_MODIFF
1524 || windows_or_buffers_changed
1525 || !EQ (current_buffer->selective_display, Qnil)
1526 || detect_input_pending ()
1527 || !NILP (XWINDOW (selected_window)->column_number_displayed)
1528 || !NILP (Vexecuting_macro));
1530 value = internal_self_insert (c, 0);
1532 if (value == 2)
1533 nonundocount = 0;
1535 /* VALUE == 1 when AFTER-CHANGE functions are
1536 installed which is the case most of the time
1537 because FONT-LOCK installs one. */
1538 if (!lose && !value)
1539 direct_output_for_insert (c);
1540 goto directly_done;
1544 /* Here for a command that isn't executed directly */
1546 #ifdef HAVE_X_WINDOWS
1547 if (display_busy_cursor_p)
1548 start_busy_cursor ();
1549 #endif
1551 nonundocount = 0;
1552 if (NILP (current_kboard->Vprefix_arg))
1553 Fundo_boundary ();
1554 Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
1556 #ifdef HAVE_X_WINDOWS
1557 if (display_busy_cursor_p)
1558 cancel_busy_cursor ();
1559 #endif
1561 directly_done: ;
1562 current_kboard->Vlast_prefix_arg = Vcurrent_prefix_arg;
1564 /* Note that the value cell will never directly contain nil
1565 if the symbol is a local variable. */
1566 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1567 safe_run_hooks (Qpost_command_hook);
1569 /* If displaying a message, resize the echo area window to fit
1570 that message's size exactly. */
1571 if (!NILP (echo_area_buffer[0]))
1572 resize_echo_area_axactly ();
1574 if (!NILP (Vdeferred_action_list))
1575 safe_run_hooks (Qdeferred_action_function);
1577 if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
1579 if (NILP (Vunread_command_events)
1580 && NILP (Vunread_input_method_events)
1581 && NILP (Vunread_post_input_method_events)
1582 && NILP (Vexecuting_macro)
1583 && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
1584 safe_run_hooks (Qpost_command_idle_hook);
1587 /* If there is a prefix argument,
1588 1) We don't want Vlast_command to be ``universal-argument''
1589 (that would be dumb), so don't set Vlast_command,
1590 2) we want to leave echoing on so that the prefix will be
1591 echoed as part of this key sequence, so don't call
1592 cancel_echoing, and
1593 3) we want to leave this_command_key_count non-zero, so that
1594 read_char will realize that it is re-reading a character, and
1595 not echo it a second time.
1597 If the command didn't actually create a prefix arg,
1598 but is merely a frame event that is transparent to prefix args,
1599 then the above doesn't apply. */
1600 if (NILP (current_kboard->Vprefix_arg) || CONSP (last_command_char))
1602 current_kboard->Vlast_command = Vthis_command;
1603 current_kboard->Vreal_last_command = real_this_command;
1604 cancel_echoing ();
1605 this_command_key_count = 0;
1606 this_single_command_key_start = 0;
1609 if (!NILP (current_buffer->mark_active) && !NILP (Vrun_hooks))
1611 if (!NILP (Vdeactivate_mark) && !NILP (Vtransient_mark_mode))
1613 current_buffer->mark_active = Qnil;
1614 call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
1616 else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
1617 call1 (Vrun_hooks, intern ("activate-mark-hook"));
1620 finalize:
1622 if (current_buffer == prev_buffer
1623 && last_point_position != PT
1624 && NILP (Vdisable_point_adjustment)
1625 && NILP (Vglobal_disable_point_adjustment))
1626 adjust_point_for_property (last_point_position);
1628 /* Install chars successfully executed in kbd macro. */
1630 if (!NILP (current_kboard->defining_kbd_macro)
1631 && NILP (current_kboard->Vprefix_arg))
1632 finalize_kbd_macro_chars ();
1634 #ifdef MULTI_KBOARD
1635 if (!was_locked)
1636 any_kboard_state ();
1637 #endif
1641 extern Lisp_Object Qcomposition, Qdisplay;
1643 /* Adjust point to a boundary of a region that has such a property
1644 that should be treated intangible. For the moment, we check
1645 `composition' and `display' property. LAST_PT is the last position
1646 of point. */
1648 static void
1649 adjust_point_for_property (last_pt)
1650 int last_pt;
1652 int start, end;
1653 Lisp_Object val;
1654 int check_composition = 1, check_display = 1;
1656 while (check_composition || check_display)
1658 if (check_composition
1659 && PT > BEGV && PT < ZV
1660 && get_property_and_range (PT, Qcomposition, &val, &start, &end, Qnil)
1661 && COMPOSITION_VALID_P (start, end, val)
1662 && start < PT && end > PT
1663 && (last_pt <= start || last_pt >= end))
1665 if (PT < last_pt)
1666 SET_PT (start);
1667 else
1668 SET_PT (end);
1669 check_display = 1;
1671 check_composition = 0;
1672 if (check_display
1673 && PT > BEGV && PT < ZV
1674 && get_property_and_range (PT, Qdisplay, &val, &start, &end, Qnil)
1675 && display_prop_intangible_p (val)
1676 && start < PT && end > PT
1677 && (last_pt <= start || last_pt >= end))
1679 if (PT < last_pt)
1680 SET_PT (start);
1681 else
1682 SET_PT (end);
1683 check_composition = 1;
1685 check_display = 0;
1689 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1691 static Lisp_Object
1692 safe_run_hooks_1 (hook)
1693 Lisp_Object hook;
1695 return call1 (Vrun_hooks, Vinhibit_quit);
1698 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1700 static Lisp_Object
1701 safe_run_hooks_error (data)
1702 Lisp_Object data;
1704 return Fset (Vinhibit_quit, Qnil);
1707 /* If we get an error while running the hook, cause the hook variable
1708 to be nil. Also inhibit quits, so that C-g won't cause the hook
1709 to mysteriously evaporate. */
1711 void
1712 safe_run_hooks (hook)
1713 Lisp_Object hook;
1715 int count = specpdl_ptr - specpdl;
1716 specbind (Qinhibit_quit, hook);
1718 internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
1720 unbind_to (count, Qnil);
1724 /* Number of seconds between polling for input. This is a Lisp
1725 variable that can be bound. */
1727 int polling_period;
1729 /* Nonzero means polling for input is temporarily suppressed. */
1731 int poll_suppress_count;
1733 /* Asynchronous timer for polling. */
1735 struct atimer *poll_timer;
1738 #ifdef POLL_FOR_INPUT
1740 /* Poll for input, so what we catch a C-g if it comes in. This
1741 function is called from x_make_frame_visible, see comment
1742 there. */
1744 void
1745 poll_for_input_1 ()
1747 if (interrupt_input_blocked == 0
1748 && !waiting_for_input)
1749 read_avail_input (0);
1752 /* Timer callback function for poll_timer. TIMER is equal to
1753 poll_timer. */
1755 void
1756 poll_for_input (timer)
1757 struct atimer *timer;
1759 if (poll_suppress_count == 0)
1760 poll_for_input_1 ();
1763 #endif /* POLL_FOR_INPUT */
1765 /* Begin signals to poll for input, if they are appropriate.
1766 This function is called unconditionally from various places. */
1768 void
1769 start_polling ()
1771 #ifdef POLL_FOR_INPUT
1772 if (read_socket_hook && !interrupt_input)
1774 /* Turn alarm handling on unconditionally. It might have
1775 been turned off in process.c. */
1776 turn_on_atimers (1);
1778 /* If poll timer doesn't exist, are we need one with
1779 a different interval, start a new one. */
1780 if (poll_timer == NULL
1781 || EMACS_SECS (poll_timer->interval) != polling_period)
1783 EMACS_TIME interval;
1785 if (poll_timer)
1786 cancel_atimer (poll_timer);
1788 EMACS_SET_SECS_USECS (interval, polling_period, 0);
1789 poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
1790 poll_for_input, NULL);
1793 /* Let the timer's callback function poll for input
1794 if this becomes zero. */
1795 --poll_suppress_count;
1797 #endif
1800 /* Nonzero if we are using polling to handle input asynchronously. */
1803 input_polling_used ()
1805 #ifdef POLL_FOR_INPUT
1806 return read_socket_hook && !interrupt_input;
1807 #else
1808 return 0;
1809 #endif
1812 /* Turn off polling. */
1814 void
1815 stop_polling ()
1817 #ifdef POLL_FOR_INPUT
1818 if (read_socket_hook && !interrupt_input)
1819 ++poll_suppress_count;
1820 #endif
1823 /* Set the value of poll_suppress_count to COUNT
1824 and start or stop polling accordingly. */
1826 void
1827 set_poll_suppress_count (count)
1828 int count;
1830 #ifdef POLL_FOR_INPUT
1831 if (count == 0 && poll_suppress_count != 0)
1833 poll_suppress_count = 1;
1834 start_polling ();
1836 else if (count != 0 && poll_suppress_count == 0)
1838 stop_polling ();
1840 poll_suppress_count = count;
1841 #endif
1844 /* Bind polling_period to a value at least N.
1845 But don't decrease it. */
1847 void
1848 bind_polling_period (n)
1849 int n;
1851 #ifdef POLL_FOR_INPUT
1852 int new = polling_period;
1854 if (n > new)
1855 new = n;
1857 stop_other_atimers (poll_timer);
1858 stop_polling ();
1859 specbind (Qpolling_period, make_number (new));
1860 /* Start a new alarm with the new period. */
1861 start_polling ();
1862 #endif
1865 /* Apply the control modifier to CHARACTER. */
1868 make_ctrl_char (c)
1869 int c;
1871 /* Save the upper bits here. */
1872 int upper = c & ~0177;
1874 c &= 0177;
1876 /* Everything in the columns containing the upper-case letters
1877 denotes a control character. */
1878 if (c >= 0100 && c < 0140)
1880 int oc = c;
1881 c &= ~0140;
1882 /* Set the shift modifier for a control char
1883 made from a shifted letter. But only for letters! */
1884 if (oc >= 'A' && oc <= 'Z')
1885 c |= shift_modifier;
1888 /* The lower-case letters denote control characters too. */
1889 else if (c >= 'a' && c <= 'z')
1890 c &= ~0140;
1892 /* Include the bits for control and shift
1893 only if the basic ASCII code can't indicate them. */
1894 else if (c >= ' ')
1895 c |= ctrl_modifier;
1897 /* Replace the high bits. */
1898 c |= (upper & ~ctrl_modifier);
1900 return c;
1903 /* Display help echo in the echo area.
1905 HELP a string means display that string, HELP nil means clear the
1906 help echo. If HELP is a function, call it with OBJECT and POS as
1907 arguments; the function should return a help string or nil for
1908 none. For all other types of HELP evaluate it to obtain a string.
1910 WINDOW is the window in which the help was generated, if any.
1911 It is nil if not in a window.
1913 If OBJECT is a buffer, POS is the position in the buffer where the
1914 `help-echo' text property was found.
1916 If OBJECT is an overlay, that overlay has a `help-echo' property,
1917 and POS is the position in the overlay's buffer under the mouse.
1919 If OBJECT is a string (an overlay string or a string displayed with
1920 the `display' property). POS is the position in that string under
1921 the mouse.
1923 OK_TO_IVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
1924 echo overwrites a keystroke echo currently displayed in the echo
1925 area.
1927 Note: this function may only be called with HELP nil or a string
1928 from X code running asynchronously. */
1930 void
1931 show_help_echo (help, window, object, pos, ok_to_overwrite_keystroke_echo)
1932 Lisp_Object help, window, object, pos;
1933 int ok_to_overwrite_keystroke_echo;
1935 if (!NILP (help) && !STRINGP (help))
1937 if (FUNCTIONP (help))
1939 Lisp_Object args[4];
1940 args[0] = help;
1941 args[1] = window;
1942 args[2] = object;
1943 args[3] = pos;
1944 help = call_function (4, args);
1946 else
1947 help = eval_form (help);
1949 if (!STRINGP (help))
1950 return;
1953 if (STRINGP (help) || NILP (help))
1955 if (!NILP (Vshow_help_function))
1956 call1 (Vshow_help_function, help);
1957 else if (/* Don't overwrite minibuffer contents. */
1958 !MINI_WINDOW_P (XWINDOW (selected_window))
1959 /* Don't overwrite a keystroke echo. */
1960 && (NILP (echo_message_buffer)
1961 || ok_to_overwrite_keystroke_echo)
1962 /* Don't overwrite a prompt. */
1963 && !cursor_in_echo_area)
1965 if (STRINGP (help))
1967 int count = specpdl_ptr - specpdl;
1968 specbind (Qmessage_truncate_lines, Qt);
1969 message3_nolog (help, XSTRING (help)->size,
1970 STRING_MULTIBYTE (help));
1971 unbind_to (count, Qnil);
1973 else
1974 message (0);
1981 /* Input of single characters from keyboard */
1983 Lisp_Object print_help ();
1984 static Lisp_Object kbd_buffer_get_event ();
1985 static void record_char ();
1987 #ifdef MULTI_KBOARD
1988 static jmp_buf wrong_kboard_jmpbuf;
1989 #endif
1991 /* read a character from the keyboard; call the redisplay if needed */
1992 /* commandflag 0 means do not do auto-saving, but do do redisplay.
1993 -1 means do not do redisplay, but do do autosaving.
1994 1 means do both. */
1996 /* The arguments MAPS and NMAPS are for menu prompting.
1997 MAPS is an array of keymaps; NMAPS is the length of MAPS.
1999 PREV_EVENT is the previous input event, or nil if we are reading
2000 the first event of a key sequence (or not reading a key sequence).
2001 If PREV_EVENT is t, that is a "magic" value that says
2002 not to run input methods, but in other respects to act as if
2003 not reading a key sequence.
2005 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2006 if we used a mouse menu to read the input, or zero otherwise. If
2007 USED_MOUSE_MENU is null, we don't dereference it.
2009 Value is t if we showed a menu and the user rejected it. */
2011 Lisp_Object
2012 read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
2013 int commandflag;
2014 int nmaps;
2015 Lisp_Object *maps;
2016 Lisp_Object prev_event;
2017 int *used_mouse_menu;
2019 Lisp_Object c;
2020 int count;
2021 jmp_buf local_getcjmp;
2022 jmp_buf save_jump;
2023 int key_already_recorded = 0;
2024 Lisp_Object tem, save;
2025 Lisp_Object previous_echo_area_message;
2026 Lisp_Object also_record;
2027 int reread;
2028 struct gcpro gcpro1, gcpro2;
2030 also_record = Qnil;
2032 before_command_key_count = this_command_key_count;
2033 before_command_echo_length = echo_length ();
2034 c = Qnil;
2035 previous_echo_area_message = Qnil;
2037 GCPRO2 (c, previous_echo_area_message);
2039 retry:
2041 reread = 0;
2042 if (CONSP (Vunread_post_input_method_events))
2044 c = XCAR (Vunread_post_input_method_events);
2045 Vunread_post_input_method_events
2046 = XCDR (Vunread_post_input_method_events);
2048 /* Undo what read_char_x_menu_prompt did when it unread
2049 additional keys returned by Fx_popup_menu. */
2050 if (CONSP (c)
2051 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2052 && NILP (XCDR (c)))
2053 c = XCAR (c);
2055 reread = 1;
2056 goto reread_first;
2059 if (unread_command_char != -1)
2061 XSETINT (c, unread_command_char);
2062 unread_command_char = -1;
2064 reread = 1;
2065 goto reread_first;
2068 if (CONSP (Vunread_command_events))
2070 c = XCAR (Vunread_command_events);
2071 Vunread_command_events = XCDR (Vunread_command_events);
2073 /* Undo what read_char_x_menu_prompt did when it unread
2074 additional keys returned by Fx_popup_menu. */
2075 if (CONSP (c)
2076 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2077 && NILP (XCDR (c)))
2078 c = XCAR (c);
2080 reread = 1;
2081 goto reread_for_input_method;
2084 if (CONSP (Vunread_input_method_events))
2086 c = XCAR (Vunread_input_method_events);
2087 Vunread_input_method_events = XCDR (Vunread_input_method_events);
2089 /* Undo what read_char_x_menu_prompt did when it unread
2090 additional keys returned by Fx_popup_menu. */
2091 if (CONSP (c)
2092 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2093 && NILP (XCDR (c)))
2094 c = XCAR (c);
2095 reread = 1;
2096 goto reread_for_input_method;
2099 /* If there is no function key translated before
2100 reset-this-command-lengths takes effect, forget about it. */
2101 before_command_restore_flag = 0;
2103 if (!NILP (Vexecuting_macro))
2105 /* We set this to Qmacro; since that's not a frame, nobody will
2106 try to switch frames on us, and the selected window will
2107 remain unchanged.
2109 Since this event came from a macro, it would be misleading to
2110 leave internal_last_event_frame set to wherever the last
2111 real event came from. Normally, a switch-frame event selects
2112 internal_last_event_frame after each command is read, but
2113 events read from a macro should never cause a new frame to be
2114 selected. */
2115 Vlast_event_frame = internal_last_event_frame = Qmacro;
2117 /* Exit the macro if we are at the end.
2118 Also, some things replace the macro with t
2119 to force an early exit. */
2120 if (EQ (Vexecuting_macro, Qt)
2121 || executing_macro_index >= XFASTINT (Flength (Vexecuting_macro)))
2123 XSETINT (c, -1);
2124 RETURN_UNGCPRO (c);
2127 c = Faref (Vexecuting_macro, make_number (executing_macro_index));
2128 if (STRINGP (Vexecuting_macro)
2129 && (XINT (c) & 0x80))
2130 XSETFASTINT (c, CHAR_META | (XINT (c) & ~0x80));
2132 executing_macro_index++;
2134 goto from_macro;
2137 if (!NILP (unread_switch_frame))
2139 c = unread_switch_frame;
2140 unread_switch_frame = Qnil;
2142 /* This event should make it into this_command_keys, and get echoed
2143 again, so we do not set `reread'. */
2144 goto reread_first;
2147 /* if redisplay was requested */
2148 if (commandflag >= 0)
2150 /* If there is pending input, process any events which are not
2151 user-visible, such as X selection_request events. */
2152 if (input_pending
2153 || detect_input_pending_run_timers (0))
2154 swallow_events (0); /* may clear input_pending */
2156 /* Redisplay if no pending input. */
2157 while (!input_pending)
2159 redisplay ();
2161 if (!input_pending)
2162 /* Normal case: no input arrived during redisplay. */
2163 break;
2165 /* Input arrived and pre-empted redisplay.
2166 Process any events which are not user-visible. */
2167 swallow_events (0);
2168 /* If that cleared input_pending, try again to redisplay. */
2172 /* Message turns off echoing unless more keystrokes turn it on again.
2174 The code in 20.x for the condition was
2176 1. echo_area_glyphs && *echo_area_glyphs
2177 2. && echo_area_glyphs != current_kboard->echobuf
2178 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2180 (1) means there's a current message displayed
2182 (2) means it's not the message from echoing from the current
2183 kboard.
2185 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2186 is set to a non-null value. This is done in read_char and it is
2187 set to echo_area_glyphs after a call to echo_char. That means
2188 ok_to_echo_at_next_pause is either null or
2189 current_kboard->echobuf with the appropriate current_kboard at
2190 that time.
2192 So, condition (3) means in clear text ok_to_echo_at_next_pause
2193 must be either null, or the current message isn't from echoing at
2194 all, or it's from echoing from a different kboard than the
2195 current one. */
2197 if (/* There currently something in the echo area */
2198 !NILP (echo_area_buffer[0])
2199 && (/* And it's either not from echoing. */
2200 !EQ (echo_area_buffer[0], echo_message_buffer)
2201 /* Or it's an echo from a different kboard. */
2202 || echo_kboard != current_kboard
2203 /* Or we explicitly allow overwriting whatever there is. */
2204 || ok_to_echo_at_next_pause == NULL))
2205 cancel_echoing ();
2206 else
2207 echo_dash ();
2209 /* Try reading a character via menu prompting in the minibuf.
2210 Try this before the sit-for, because the sit-for
2211 would do the wrong thing if we are supposed to do
2212 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2213 after a mouse event so don't try a minibuf menu. */
2214 c = Qnil;
2215 if (nmaps > 0 && INTERACTIVE
2216 && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
2217 /* Don't bring up a menu if we already have another event. */
2218 && NILP (Vunread_command_events)
2219 && unread_command_char < 0
2220 && !detect_input_pending_run_timers (0))
2222 c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
2223 if (! NILP (c))
2225 key_already_recorded = 1;
2226 goto non_reread_1;
2230 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2231 We will do that below, temporarily for short sections of code,
2232 when appropriate. local_getcjmp must be in effect
2233 around any call to sit_for or kbd_buffer_get_event;
2234 it *must not* be in effect when we call redisplay. */
2236 if (_setjmp (local_getcjmp))
2238 XSETINT (c, quit_char);
2239 internal_last_event_frame = selected_frame;
2240 Vlast_event_frame = internal_last_event_frame;
2241 /* If we report the quit char as an event,
2242 don't do so more than once. */
2243 if (!NILP (Vinhibit_quit))
2244 Vquit_flag = Qnil;
2246 #ifdef MULTI_KBOARD
2248 KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
2249 if (kb != current_kboard)
2251 Lisp_Object *tailp = &kb->kbd_queue;
2252 /* We shouldn't get here if we were in single-kboard mode! */
2253 if (single_kboard)
2254 abort ();
2255 while (CONSP (*tailp))
2256 tailp = &XCDR (*tailp);
2257 if (!NILP (*tailp))
2258 abort ();
2259 *tailp = Fcons (c, Qnil);
2260 kb->kbd_queue_has_data = 1;
2261 current_kboard = kb;
2262 /* This is going to exit from read_char
2263 so we had better get rid of this frame's stuff. */
2264 UNGCPRO;
2265 longjmp (wrong_kboard_jmpbuf, 1);
2268 #endif
2269 goto non_reread;
2272 timer_start_idle ();
2274 /* If in middle of key sequence and minibuffer not active,
2275 start echoing if enough time elapses. */
2277 if (minibuf_level == 0
2278 && !current_kboard->immediate_echo
2279 && this_command_key_count > 0
2280 && ! noninteractive
2281 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2282 && NILP (Fzerop (Vecho_keystrokes))
2283 && (/* No message. */
2284 NILP (echo_area_buffer[0])
2285 /* Or empty message. */
2286 || (BUF_BEG (XBUFFER (echo_area_buffer[0]))
2287 == BUF_Z (XBUFFER (echo_area_buffer[0])))
2288 /* Or already echoing from same kboard. */
2289 || (echo_kboard && ok_to_echo_at_next_pause == echo_kboard)
2290 /* Or not echoing before and echoing allowed. */
2291 || (!echo_kboard && ok_to_echo_at_next_pause)))
2293 Lisp_Object tem0;
2295 /* After a mouse event, start echoing right away.
2296 This is because we are probably about to display a menu,
2297 and we don't want to delay before doing so. */
2298 if (EVENT_HAS_PARAMETERS (prev_event))
2299 echo_now ();
2300 else
2302 int sec, usec;
2303 double duration = extract_float (Vecho_keystrokes);
2304 sec = (int) duration;
2305 usec = (duration - sec) * 1000000;
2306 save_getcjmp (save_jump);
2307 restore_getcjmp (local_getcjmp);
2308 tem0 = sit_for (sec, usec, 1, 1, 0);
2309 restore_getcjmp (save_jump);
2310 if (EQ (tem0, Qt)
2311 && ! CONSP (Vunread_command_events))
2312 echo_now ();
2316 /* Maybe auto save due to number of keystrokes. */
2318 if (commandflag != 0
2319 && auto_save_interval > 0
2320 && num_nonmacro_input_events - last_auto_save > max (auto_save_interval, 20)
2321 && !detect_input_pending_run_timers (0))
2323 Fdo_auto_save (Qnil, Qnil);
2324 /* Hooks can actually change some buffers in auto save. */
2325 redisplay ();
2328 /* Try reading using an X menu.
2329 This is never confused with reading using the minibuf
2330 because the recursive call of read_char in read_char_minibuf_menu_prompt
2331 does not pass on any keymaps. */
2333 if (nmaps > 0 && INTERACTIVE
2334 && !NILP (prev_event)
2335 && EVENT_HAS_PARAMETERS (prev_event)
2336 && !EQ (XCAR (prev_event), Qmenu_bar)
2337 && !EQ (XCAR (prev_event), Qtool_bar)
2338 /* Don't bring up a menu if we already have another event. */
2339 && NILP (Vunread_command_events)
2340 && unread_command_char < 0)
2342 c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
2344 /* Now that we have read an event, Emacs is not idle. */
2345 timer_stop_idle ();
2347 RETURN_UNGCPRO (c);
2350 /* Maybe autosave and/or garbage collect due to idleness. */
2352 if (INTERACTIVE && NILP (c))
2354 int delay_level, buffer_size;
2356 /* Slow down auto saves logarithmically in size of current buffer,
2357 and garbage collect while we're at it. */
2358 if (! MINI_WINDOW_P (XWINDOW (selected_window)))
2359 last_non_minibuf_size = Z - BEG;
2360 buffer_size = (last_non_minibuf_size >> 8) + 1;
2361 delay_level = 0;
2362 while (buffer_size > 64)
2363 delay_level++, buffer_size -= buffer_size >> 2;
2364 if (delay_level < 4) delay_level = 4;
2365 /* delay_level is 4 for files under around 50k, 7 at 100k,
2366 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2368 /* Auto save if enough time goes by without input. */
2369 if (commandflag != 0
2370 && num_nonmacro_input_events > last_auto_save
2371 && INTEGERP (Vauto_save_timeout)
2372 && XINT (Vauto_save_timeout) > 0)
2374 Lisp_Object tem0;
2376 save_getcjmp (save_jump);
2377 restore_getcjmp (local_getcjmp);
2378 tem0 = sit_for (delay_level * XFASTINT (Vauto_save_timeout) / 4,
2379 0, 1, 1, 0);
2380 restore_getcjmp (save_jump);
2382 if (EQ (tem0, Qt)
2383 && ! CONSP (Vunread_command_events))
2385 Fdo_auto_save (Qnil, Qnil);
2387 /* If we have auto-saved and there is still no input
2388 available, garbage collect if there has been enough
2389 consing going on to make it worthwhile. */
2390 if (!detect_input_pending_run_timers (0)
2391 && consing_since_gc > gc_cons_threshold / 2)
2392 Fgarbage_collect ();
2394 redisplay ();
2399 /* If this has become non-nil here, it has been set by a timer
2400 or sentinel or filter. */
2401 if (CONSP (Vunread_command_events))
2403 c = XCAR (Vunread_command_events);
2404 Vunread_command_events = XCDR (Vunread_command_events);
2407 /* Read something from current KBOARD's side queue, if possible. */
2409 if (NILP (c))
2411 if (current_kboard->kbd_queue_has_data)
2413 if (!CONSP (current_kboard->kbd_queue))
2414 abort ();
2415 c = XCAR (current_kboard->kbd_queue);
2416 current_kboard->kbd_queue
2417 = XCDR (current_kboard->kbd_queue);
2418 if (NILP (current_kboard->kbd_queue))
2419 current_kboard->kbd_queue_has_data = 0;
2420 input_pending = readable_events (0);
2421 if (EVENT_HAS_PARAMETERS (c)
2422 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qswitch_frame))
2423 internal_last_event_frame = XCAR (XCDR (c));
2424 Vlast_event_frame = internal_last_event_frame;
2428 #ifdef MULTI_KBOARD
2429 /* If current_kboard's side queue is empty check the other kboards.
2430 If one of them has data that we have not yet seen here,
2431 switch to it and process the data waiting for it.
2433 Note: if the events queued up for another kboard
2434 have already been seen here, and therefore are not a complete command,
2435 the kbd_queue_has_data field is 0, so we skip that kboard here.
2436 That's to avoid an infinite loop switching between kboards here. */
2437 if (NILP (c) && !single_kboard)
2439 KBOARD *kb;
2440 for (kb = all_kboards; kb; kb = kb->next_kboard)
2441 if (kb->kbd_queue_has_data)
2443 current_kboard = kb;
2444 /* This is going to exit from read_char
2445 so we had better get rid of this frame's stuff. */
2446 UNGCPRO;
2447 longjmp (wrong_kboard_jmpbuf, 1);
2450 #endif
2452 wrong_kboard:
2454 stop_polling ();
2456 /* Finally, we read from the main queue,
2457 and if that gives us something we can't use yet, we put it on the
2458 appropriate side queue and try again. */
2460 if (NILP (c))
2462 KBOARD *kb;
2464 /* Actually read a character, waiting if necessary. */
2465 save_getcjmp (save_jump);
2466 restore_getcjmp (local_getcjmp);
2467 c = kbd_buffer_get_event (&kb, used_mouse_menu);
2468 restore_getcjmp (save_jump);
2470 #ifdef MULTI_KBOARD
2471 if (! NILP (c) && (kb != current_kboard))
2473 Lisp_Object *tailp = &kb->kbd_queue;
2474 while (CONSP (*tailp))
2475 tailp = &XCDR (*tailp);
2476 if (!NILP (*tailp))
2477 abort ();
2478 *tailp = Fcons (c, Qnil);
2479 kb->kbd_queue_has_data = 1;
2480 c = Qnil;
2481 if (single_kboard)
2482 goto wrong_kboard;
2483 current_kboard = kb;
2484 /* This is going to exit from read_char
2485 so we had better get rid of this frame's stuff. */
2486 UNGCPRO;
2487 longjmp (wrong_kboard_jmpbuf, 1);
2489 #endif
2492 /* Terminate Emacs in batch mode if at eof. */
2493 if (noninteractive && INTEGERP (c) && XINT (c) < 0)
2494 Fkill_emacs (make_number (1));
2496 if (INTEGERP (c))
2498 /* Add in any extra modifiers, where appropriate. */
2499 if ((extra_keyboard_modifiers & CHAR_CTL)
2500 || ((extra_keyboard_modifiers & 0177) < ' '
2501 && (extra_keyboard_modifiers & 0177) != 0))
2502 XSETINT (c, make_ctrl_char (XINT (c)));
2504 /* Transfer any other modifier bits directly from
2505 extra_keyboard_modifiers to c. Ignore the actual character code
2506 in the low 16 bits of extra_keyboard_modifiers. */
2507 XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
2510 non_reread:
2512 timer_stop_idle ();
2514 start_polling ();
2516 if (NILP (c))
2518 if (commandflag >= 0
2519 && !input_pending && !detect_input_pending_run_timers (0))
2520 redisplay ();
2522 goto wrong_kboard;
2525 non_reread_1:
2527 /* Buffer switch events are only for internal wakeups
2528 so don't show them to the user.
2529 Also, don't record a key if we already did. */
2530 if (BUFFERP (c) || key_already_recorded)
2531 RETURN_UNGCPRO (c);
2533 /* Process special events within read_char
2534 and loop around to read another event. */
2535 save = Vquit_flag;
2536 Vquit_flag = Qnil;
2537 tem = get_keyelt (access_keymap (get_keymap_1 (Vspecial_event_map, 0, 0),
2538 c, 0, 0), 1);
2539 Vquit_flag = save;
2541 if (!NILP (tem))
2543 int was_locked = single_kboard;
2545 last_input_char = c;
2546 Fcommand_execute (tem, Qnil, Fvector (1, &last_input_char), Qt);
2548 /* Resume allowing input from any kboard, if that was true before. */
2549 if (!was_locked)
2550 any_kboard_state ();
2552 goto retry;
2555 /* Handle things that only apply to characters. */
2556 if (INTEGERP (c))
2558 /* If kbd_buffer_get_event gave us an EOF, return that. */
2559 if (XINT (c) == -1)
2560 RETURN_UNGCPRO (c);
2562 if ((STRINGP (Vkeyboard_translate_table)
2563 && XSTRING (Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
2564 || (VECTORP (Vkeyboard_translate_table)
2565 && XVECTOR (Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
2566 || (CHAR_TABLE_P (Vkeyboard_translate_table)
2567 && CHAR_TABLE_ORDINARY_SLOTS > (unsigned) XFASTINT (c)))
2569 Lisp_Object d;
2570 d = Faref (Vkeyboard_translate_table, c);
2571 /* nil in keyboard-translate-table means no translation. */
2572 if (!NILP (d))
2573 c = d;
2577 /* If this event is a mouse click in the menu bar,
2578 return just menu-bar for now. Modify the mouse click event
2579 so we won't do this twice, then queue it up. */
2580 if (EVENT_HAS_PARAMETERS (c)
2581 && CONSP (XCDR (c))
2582 && CONSP (EVENT_START (c))
2583 && CONSP (XCDR (EVENT_START (c))))
2585 Lisp_Object posn;
2587 posn = POSN_BUFFER_POSN (EVENT_START (c));
2588 /* Handle menu-bar events:
2589 insert the dummy prefix event `menu-bar'. */
2590 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
2592 /* Change menu-bar to (menu-bar) as the event "position". */
2593 POSN_BUFFER_POSN (EVENT_START (c)) = Fcons (posn, Qnil);
2595 also_record = c;
2596 Vunread_command_events = Fcons (c, Vunread_command_events);
2597 c = posn;
2601 /* Store these characters into recent_keys, the dribble file if any,
2602 and the keyboard macro being defined, if any. */
2603 record_char (c);
2604 if (! NILP (also_record))
2605 record_char (also_record);
2607 /* Wipe the echo area.
2608 But first, if we are about to use an input method,
2609 save the echo area contents for it to refer to. */
2610 if (INTEGERP (c)
2611 && ! NILP (Vinput_method_function)
2612 && (unsigned) XINT (c) >= ' '
2613 && (unsigned) XINT (c) != 127
2614 && (unsigned) XINT (c) < 256)
2616 previous_echo_area_message = Fcurrent_message ();
2617 Vinput_method_previous_message = previous_echo_area_message;
2620 /* Now wipe the echo area, except for help events which do their
2621 own stuff with the echo area. */
2622 if (!CONSP (c) || !(EQ (Qhelp_echo, XCAR (c))))
2624 if (!NILP (echo_area_buffer[0]))
2625 safe_run_hooks (Qecho_area_clear_hook);
2626 clear_message (1, 0);
2629 reread_for_input_method:
2630 from_macro:
2631 /* Pass this to the input method, if appropriate. */
2632 if (INTEGERP (c)
2633 && ! NILP (Vinput_method_function)
2634 /* Don't run the input method within a key sequence,
2635 after the first event of the key sequence. */
2636 && NILP (prev_event)
2637 && (unsigned) XINT (c) >= ' '
2638 && (unsigned) XINT (c) != 127
2639 && (unsigned) XINT (c) < 256)
2641 Lisp_Object keys;
2642 int key_count;
2643 struct gcpro gcpro1;
2644 int count = specpdl_ptr - specpdl;
2646 /* Save the echo status. */
2647 int saved_immediate_echo = current_kboard->immediate_echo;
2648 struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
2649 int saved_echo_after_prompt = current_kboard->echo_after_prompt;
2651 if (before_command_restore_flag)
2653 this_command_key_count = before_command_key_count_1;
2654 if (this_command_key_count < this_single_command_key_start)
2655 this_single_command_key_start = this_command_key_count;
2656 echo_truncate (before_command_echo_length_1);
2657 before_command_restore_flag = 0;
2660 /* Save the this_command_keys status. */
2661 key_count = this_command_key_count;
2663 if (key_count > 0)
2664 keys = Fcopy_sequence (this_command_keys);
2665 else
2666 keys = Qnil;
2667 GCPRO1 (keys);
2669 /* Clear out this_command_keys. */
2670 this_command_key_count = 0;
2672 /* Now wipe the echo area. */
2673 if (!NILP (echo_area_buffer[0]))
2674 safe_run_hooks (Qecho_area_clear_hook);
2675 clear_message (1, 0);
2676 echo_truncate (0);
2678 /* If we are not reading a key sequence,
2679 never use the echo area. */
2680 if (maps == 0)
2682 specbind (Qinput_method_use_echo_area, Qt);
2685 /* Call the input method. */
2686 tem = call1 (Vinput_method_function, c);
2688 tem = unbind_to (count, tem);
2690 /* Restore the saved echoing state
2691 and this_command_keys state. */
2692 this_command_key_count = key_count;
2693 if (key_count > 0)
2694 this_command_keys = keys;
2696 cancel_echoing ();
2697 ok_to_echo_at_next_pause = saved_ok_to_echo;
2698 current_kboard->echo_after_prompt = saved_echo_after_prompt;
2699 if (saved_immediate_echo)
2700 echo_now ();
2702 UNGCPRO;
2704 /* The input method can return no events. */
2705 if (! CONSP (tem))
2707 /* Bring back the previous message, if any. */
2708 if (! NILP (previous_echo_area_message))
2709 message_with_string ("%s", previous_echo_area_message, 0);
2710 goto retry;
2712 /* It returned one event or more. */
2713 c = XCAR (tem);
2714 Vunread_post_input_method_events
2715 = nconc2 (XCDR (tem), Vunread_post_input_method_events);
2718 reread_first:
2720 /* Display help if not echoing. */
2721 if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
2723 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
2724 Lisp_Object help, object, position, window;
2725 help = Fnth (make_number (2), c);
2726 window = Fnth (make_number (3), c);
2727 object = Fnth (make_number (4), c);
2728 position = Fnth (make_number (5), c);
2729 show_help_echo (help, window, object, position, 0);
2730 goto retry;
2733 if (this_command_key_count == 0 || ! reread)
2735 before_command_key_count = this_command_key_count;
2736 before_command_echo_length = echo_length ();
2738 /* Don't echo mouse motion events. */
2739 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2740 && NILP (Fzerop (Vecho_keystrokes))
2741 && ! (EVENT_HAS_PARAMETERS (c)
2742 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
2744 echo_char (c);
2745 if (! NILP (also_record))
2746 echo_char (also_record);
2747 /* Once we reread a character, echoing can happen
2748 the next time we pause to read a new one. */
2749 ok_to_echo_at_next_pause = current_kboard;
2752 /* Record this character as part of the current key. */
2753 add_command_key (c);
2754 if (! NILP (also_record))
2755 add_command_key (also_record);
2758 last_input_char = c;
2759 num_input_events++;
2761 /* Process the help character specially if enabled */
2762 if (!NILP (Vhelp_form) && help_char_p (c))
2764 Lisp_Object tem0;
2765 count = specpdl_ptr - specpdl;
2767 record_unwind_protect (Fset_window_configuration,
2768 Fcurrent_window_configuration (Qnil));
2770 tem0 = Feval (Vhelp_form);
2771 if (STRINGP (tem0))
2772 internal_with_output_to_temp_buffer ("*Help*", print_help, tem0);
2774 cancel_echoing ();
2776 c = read_char (0, 0, 0, Qnil, 0);
2777 while (BUFFERP (c));
2778 /* Remove the help from the frame */
2779 unbind_to (count, Qnil);
2781 redisplay ();
2782 if (EQ (c, make_number (040)))
2784 cancel_echoing ();
2786 c = read_char (0, 0, 0, Qnil, 0);
2787 while (BUFFERP (c));
2791 RETURN_UNGCPRO (c);
2794 /* Record a key that came from a mouse menu.
2795 Record it for echoing, for this-command-keys, and so on. */
2797 static void
2798 record_menu_key (c)
2799 Lisp_Object c;
2801 /* Wipe the echo area. */
2802 clear_message (1, 0);
2804 record_char (c);
2806 before_command_key_count = this_command_key_count;
2807 before_command_echo_length = echo_length ();
2809 /* Don't echo mouse motion events. */
2810 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2811 && NILP (Fzerop (Vecho_keystrokes)))
2813 echo_char (c);
2815 /* Once we reread a character, echoing can happen
2816 the next time we pause to read a new one. */
2817 ok_to_echo_at_next_pause = 0;
2820 /* Record this character as part of the current key. */
2821 add_command_key (c);
2823 /* Re-reading in the middle of a command */
2824 last_input_char = c;
2825 num_input_events++;
2828 /* Return 1 if should recognize C as "the help character". */
2831 help_char_p (c)
2832 Lisp_Object c;
2834 Lisp_Object tail;
2836 if (EQ (c, Vhelp_char))
2837 return 1;
2838 for (tail = Vhelp_event_list; CONSP (tail); tail = XCDR (tail))
2839 if (EQ (c, XCAR (tail)))
2840 return 1;
2841 return 0;
2844 /* Record the input event C in various ways. */
2846 static void
2847 record_char (c)
2848 Lisp_Object c;
2850 total_keys++;
2851 XVECTOR (recent_keys)->contents[recent_keys_index] = c;
2852 if (++recent_keys_index >= NUM_RECENT_KEYS)
2853 recent_keys_index = 0;
2855 /* Write c to the dribble file. If c is a lispy event, write
2856 the event's symbol to the dribble file, in <brackets>. Bleaugh.
2857 If you, dear reader, have a better idea, you've got the source. :-) */
2858 if (dribble)
2860 if (INTEGERP (c))
2862 if (XUINT (c) < 0x100)
2863 putc (XINT (c), dribble);
2864 else
2865 fprintf (dribble, " 0x%x", (int) XUINT (c));
2867 else
2869 Lisp_Object dribblee;
2871 /* If it's a structured event, take the event header. */
2872 dribblee = EVENT_HEAD (c);
2874 if (SYMBOLP (dribblee))
2876 putc ('<', dribble);
2877 fwrite (XSYMBOL (dribblee)->name->data, sizeof (char),
2878 STRING_BYTES (XSYMBOL (dribblee)->name),
2879 dribble);
2880 putc ('>', dribble);
2884 fflush (dribble);
2887 store_kbd_macro_char (c);
2889 num_nonmacro_input_events++;
2892 Lisp_Object
2893 print_help (object)
2894 Lisp_Object object;
2896 struct buffer *old = current_buffer;
2897 Fprinc (object, Qnil);
2898 set_buffer_internal (XBUFFER (Vstandard_output));
2899 call0 (intern ("help-mode"));
2900 set_buffer_internal (old);
2901 return Qnil;
2904 /* Copy out or in the info on where C-g should throw to.
2905 This is used when running Lisp code from within get_char,
2906 in case get_char is called recursively.
2907 See read_process_output. */
2909 static void
2910 save_getcjmp (temp)
2911 jmp_buf temp;
2913 bcopy (getcjmp, temp, sizeof getcjmp);
2916 static void
2917 restore_getcjmp (temp)
2918 jmp_buf temp;
2920 bcopy (temp, getcjmp, sizeof getcjmp);
2923 #ifdef HAVE_MOUSE
2925 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
2926 of this function. */
2928 static Lisp_Object
2929 tracking_off (old_value)
2930 Lisp_Object old_value;
2932 do_mouse_tracking = old_value;
2933 if (NILP (old_value))
2935 /* Redisplay may have been preempted because there was input
2936 available, and it assumes it will be called again after the
2937 input has been processed. If the only input available was
2938 the sort that we have just disabled, then we need to call
2939 redisplay. */
2940 if (!readable_events (1))
2942 redisplay_preserve_echo_area ();
2943 get_input_pending (&input_pending, 1);
2946 return Qnil;
2949 DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
2950 "Evaluate BODY with mouse movement events enabled.\n\
2951 Within a `track-mouse' form, mouse motion generates input events that\n\
2952 you can read with `read-event'.\n\
2953 Normally, mouse motion is ignored.")
2954 (args)
2955 Lisp_Object args;
2957 int count = specpdl_ptr - specpdl;
2958 Lisp_Object val;
2960 record_unwind_protect (tracking_off, do_mouse_tracking);
2962 do_mouse_tracking = Qt;
2964 val = Fprogn (args);
2965 return unbind_to (count, val);
2968 /* If mouse has moved on some frame, return one of those frames.
2969 Return 0 otherwise. */
2971 static FRAME_PTR
2972 some_mouse_moved ()
2974 Lisp_Object tail, frame;
2976 FOR_EACH_FRAME (tail, frame)
2978 if (XFRAME (frame)->mouse_moved)
2979 return XFRAME (frame);
2982 return 0;
2985 #endif /* HAVE_MOUSE */
2987 /* Low level keyboard/mouse input.
2988 kbd_buffer_store_event places events in kbd_buffer, and
2989 kbd_buffer_get_event retrieves them. */
2991 /* Return true iff there are any events in the queue that read-char
2992 would return. If this returns false, a read-char would block. */
2993 static int
2994 readable_events (do_timers_now)
2995 int do_timers_now;
2997 if (do_timers_now)
2998 timer_check (do_timers_now);
3000 if (kbd_fetch_ptr != kbd_store_ptr)
3001 return 1;
3002 #ifdef HAVE_MOUSE
3003 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3004 return 1;
3005 #endif
3006 if (single_kboard)
3008 if (current_kboard->kbd_queue_has_data)
3009 return 1;
3011 else
3013 KBOARD *kb;
3014 for (kb = all_kboards; kb; kb = kb->next_kboard)
3015 if (kb->kbd_queue_has_data)
3016 return 1;
3018 return 0;
3021 /* Set this for debugging, to have a way to get out */
3022 int stop_character;
3024 #ifdef MULTI_KBOARD
3025 static KBOARD *
3026 event_to_kboard (event)
3027 struct input_event *event;
3029 Lisp_Object frame;
3030 frame = event->frame_or_window;
3031 if (CONSP (frame))
3032 frame = XCAR (frame);
3033 else if (WINDOWP (frame))
3034 frame = WINDOW_FRAME (XWINDOW (frame));
3036 /* There are still some events that don't set this field.
3037 For now, just ignore the problem.
3038 Also ignore dead frames here. */
3039 if (!FRAMEP (frame) || !FRAME_LIVE_P (XFRAME (frame)))
3040 return 0;
3041 else
3042 return FRAME_KBOARD (XFRAME (frame));
3044 #endif
3046 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3048 void
3049 kbd_buffer_store_event (event)
3050 register struct input_event *event;
3052 if (event->kind == no_event)
3053 abort ();
3055 if (event->kind == ascii_keystroke)
3057 register int c = event->code & 0377;
3059 if (event->modifiers & ctrl_modifier)
3060 c = make_ctrl_char (c);
3062 c |= (event->modifiers
3063 & (meta_modifier | alt_modifier
3064 | hyper_modifier | super_modifier));
3066 if (c == quit_char)
3068 extern SIGTYPE interrupt_signal ();
3069 #ifdef MULTI_KBOARD
3070 KBOARD *kb;
3071 struct input_event *sp;
3073 if (single_kboard
3074 && (kb = FRAME_KBOARD (XFRAME (event->frame_or_window)),
3075 kb != current_kboard))
3077 kb->kbd_queue
3078 = Fcons (make_lispy_switch_frame (event->frame_or_window),
3079 Fcons (make_number (c), Qnil));
3080 kb->kbd_queue_has_data = 1;
3081 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3083 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3084 sp = kbd_buffer;
3086 if (event_to_kboard (sp) == kb)
3088 sp->kind = no_event;
3089 sp->frame_or_window = Qnil;
3090 sp->arg = Qnil;
3093 return;
3095 #endif
3097 /* If this results in a quit_char being returned to Emacs as
3098 input, set Vlast_event_frame properly. If this doesn't
3099 get returned to Emacs as an event, the next event read
3100 will set Vlast_event_frame again, so this is safe to do. */
3102 Lisp_Object focus;
3104 focus = FRAME_FOCUS_FRAME (XFRAME (event->frame_or_window));
3105 if (NILP (focus))
3106 focus = event->frame_or_window;
3107 internal_last_event_frame = focus;
3108 Vlast_event_frame = focus;
3111 last_event_timestamp = event->timestamp;
3112 interrupt_signal ();
3113 return;
3116 if (c && c == stop_character)
3118 sys_suspend ();
3119 return;
3122 /* Don't insert two buffer_switch_event's in a row.
3123 Just ignore the second one. */
3124 else if (event->kind == buffer_switch_event
3125 && kbd_fetch_ptr != kbd_store_ptr
3126 && kbd_store_ptr->kind == buffer_switch_event)
3127 return;
3129 if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
3130 kbd_store_ptr = kbd_buffer;
3132 /* Don't let the very last slot in the buffer become full,
3133 since that would make the two pointers equal,
3134 and that is indistinguishable from an empty buffer.
3135 Discard the event if it would fill the last slot. */
3136 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
3138 int idx;
3140 #if 0 /* The selection_request_event case looks bogus, and it's error
3141 prone to assign individual members for other events, in case
3142 the input_event structure is changed. --2000-07-13, gerd. */
3143 struct input_event *sp = kbd_store_ptr;
3144 sp->kind = event->kind;
3145 if (event->kind == selection_request_event)
3147 /* We must not use the ordinary copying code for this case,
3148 since `part' is an enum and copying it might not copy enough
3149 in this case. */
3150 bcopy (event, (char *) sp, sizeof (*event));
3152 else
3155 sp->code = event->code;
3156 sp->part = event->part;
3157 sp->frame_or_window = event->frame_or_window;
3158 sp->arg = event->arg;
3159 sp->modifiers = event->modifiers;
3160 sp->x = event->x;
3161 sp->y = event->y;
3162 sp->timestamp = event->timestamp;
3164 #else
3165 *kbd_store_ptr = *event;
3166 #endif
3168 idx = 2 * (kbd_store_ptr - kbd_buffer);
3169 ASET (kbd_buffer_gcpro, idx, event->frame_or_window);
3170 ASET (kbd_buffer_gcpro, idx + 1, event->arg);
3171 ++kbd_store_ptr;
3176 /* Generate HELP_EVENT input_events in BUFP.
3178 HELP is the help form.
3180 FRAME is the frame on which the help is generated. OBJECT is the
3181 Lisp object where the help was found (a buffer, a string, an
3182 overlay, or nil if neither from a string nor from a buffer. POS is
3183 the position within OBJECT where the help was found.
3185 Value is the number of input_events generated. */
3188 gen_help_event (bufp, help, frame, window, object, pos)
3189 struct input_event *bufp;
3190 Lisp_Object help, frame, object, window;
3191 int pos;
3193 bufp->kind = HELP_EVENT;
3194 bufp->frame_or_window = frame;
3195 bufp->arg = object;
3196 bufp->x = make_number (pos);
3197 bufp->code = 0;
3199 ++bufp;
3200 bufp->kind = HELP_EVENT;
3201 bufp->frame_or_window = WINDOWP (window) ? window : frame;
3202 bufp->arg = help;
3203 bufp->code = 1;
3205 return 2;
3209 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3211 void
3212 kbd_buffer_store_help_event (frame, help)
3213 Lisp_Object frame, help;
3215 struct input_event event;
3217 event.kind = HELP_EVENT;
3218 event.frame_or_window = frame;
3219 event.arg = Qnil;
3220 event.x = make_number (0);
3221 event.code = 0;
3222 kbd_buffer_store_event (&event);
3224 event.kind = HELP_EVENT;
3225 event.frame_or_window = frame;
3226 event.arg = help;
3227 event.x = make_number (0);
3228 event.code = 1;
3229 kbd_buffer_store_event (&event);
3233 /* Discard any mouse events in the event buffer by setting them to
3234 no_event. */
3235 void
3236 discard_mouse_events ()
3238 struct input_event *sp;
3239 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3241 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3242 sp = kbd_buffer;
3244 if (sp->kind == mouse_click
3245 #ifdef WINDOWSNT
3246 || sp->kind == w32_scroll_bar_click
3247 #endif
3248 || sp->kind == scroll_bar_click)
3250 sp->kind = no_event;
3255 /* Return non-zero if there are any events waiting in the event buffer
3256 whose .kind is not no_event. If DISCARD is non-zero, discard all
3257 no_event placeholders up to the first real event. If there are no
3258 real events waiting and DISCARD is non-zero, this function makes
3259 the event buffer empty as side effect. */
3261 kbd_buffer_events_waiting (discard)
3262 int discard;
3264 struct input_event *sp;
3265 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3267 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3268 sp = kbd_buffer;
3270 if (sp->kind != no_event)
3271 return 1;
3272 if (discard)
3273 kbd_fetch_ptr = sp;
3275 if (discard)
3276 kbd_fetch_ptr = sp;
3277 return 0;
3280 /* Read one event from the event buffer, waiting if necessary.
3281 The value is a Lisp object representing the event.
3282 The value is nil for an event that should be ignored,
3283 or that was handled here.
3284 We always read and discard one event. */
3286 static Lisp_Object
3287 kbd_buffer_get_event (kbp, used_mouse_menu)
3288 KBOARD **kbp;
3289 int *used_mouse_menu;
3291 register int c;
3292 Lisp_Object obj;
3294 if (noninteractive)
3296 c = getchar ();
3297 XSETINT (obj, c);
3298 *kbp = current_kboard;
3299 return obj;
3302 /* Wait until there is input available. */
3303 for (;;)
3305 if (kbd_fetch_ptr != kbd_store_ptr)
3306 break;
3307 #ifdef HAVE_MOUSE
3308 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3309 break;
3310 #endif
3312 /* If the quit flag is set, then read_char will return
3313 quit_char, so that counts as "available input." */
3314 if (!NILP (Vquit_flag))
3315 quit_throw_to_read_char ();
3317 /* One way or another, wait until input is available; then, if
3318 interrupt handlers have not read it, read it now. */
3320 #ifdef OLDVMS
3321 wait_for_kbd_input ();
3322 #else
3323 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3324 #ifdef SIGIO
3325 gobble_input (0);
3326 #endif /* SIGIO */
3327 if (kbd_fetch_ptr != kbd_store_ptr)
3328 break;
3329 #ifdef HAVE_MOUSE
3330 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3331 break;
3332 #endif
3334 Lisp_Object minus_one;
3336 XSETINT (minus_one, -1);
3337 wait_reading_process_input (0, 0, minus_one, 1);
3339 if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
3340 /* Pass 1 for EXPECT since we just waited to have input. */
3341 read_avail_input (1);
3343 #endif /* not VMS */
3346 if (CONSP (Vunread_command_events))
3348 Lisp_Object first;
3349 first = XCAR (Vunread_command_events);
3350 Vunread_command_events = XCDR (Vunread_command_events);
3351 *kbp = current_kboard;
3352 return first;
3355 /* At this point, we know that there is a readable event available
3356 somewhere. If the event queue is empty, then there must be a
3357 mouse movement enabled and available. */
3358 if (kbd_fetch_ptr != kbd_store_ptr)
3360 struct input_event *event;
3362 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3363 ? kbd_fetch_ptr
3364 : kbd_buffer);
3366 last_event_timestamp = event->timestamp;
3368 #ifdef MULTI_KBOARD
3369 *kbp = event_to_kboard (event);
3370 if (*kbp == 0)
3371 *kbp = current_kboard; /* Better than returning null ptr? */
3372 #else
3373 *kbp = &the_only_kboard;
3374 #endif
3376 obj = Qnil;
3378 /* These two kinds of events get special handling
3379 and don't actually appear to the command loop.
3380 We return nil for them. */
3381 if (event->kind == selection_request_event)
3383 #ifdef HAVE_X11
3384 struct input_event copy;
3386 /* Remove it from the buffer before processing it,
3387 since otherwise swallow_events will see it
3388 and process it again. */
3389 copy = *event;
3390 kbd_fetch_ptr = event + 1;
3391 input_pending = readable_events (0);
3392 x_handle_selection_request (&copy);
3393 #else
3394 /* We're getting selection request events, but we don't have
3395 a window system. */
3396 abort ();
3397 #endif
3400 else if (event->kind == selection_clear_event)
3402 #ifdef HAVE_X11
3403 struct input_event copy;
3405 /* Remove it from the buffer before processing it. */
3406 copy = *event;
3407 kbd_fetch_ptr = event + 1;
3408 input_pending = readable_events (0);
3409 x_handle_selection_clear (&copy);
3410 #else
3411 /* We're getting selection request events, but we don't have
3412 a window system. */
3413 abort ();
3414 #endif
3416 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3417 else if (event->kind == delete_window_event)
3419 /* Make an event (delete-frame (FRAME)). */
3420 obj = Fcons (event->frame_or_window, Qnil);
3421 obj = Fcons (Qdelete_frame, Fcons (obj, Qnil));
3422 kbd_fetch_ptr = event + 1;
3424 else if (event->kind == iconify_event)
3426 /* Make an event (iconify-frame (FRAME)). */
3427 obj = Fcons (event->frame_or_window, Qnil);
3428 obj = Fcons (Qiconify_frame, Fcons (obj, Qnil));
3429 kbd_fetch_ptr = event + 1;
3431 else if (event->kind == deiconify_event)
3433 /* Make an event (make-frame-visible (FRAME)). */
3434 obj = Fcons (event->frame_or_window, Qnil);
3435 obj = Fcons (Qmake_frame_visible, Fcons (obj, Qnil));
3436 kbd_fetch_ptr = event + 1;
3438 #endif
3439 else if (event->kind == buffer_switch_event)
3441 /* The value doesn't matter here; only the type is tested. */
3442 XSETBUFFER (obj, current_buffer);
3443 kbd_fetch_ptr = event + 1;
3445 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
3446 else if (event->kind == menu_bar_activate_event)
3448 kbd_fetch_ptr = event + 1;
3449 input_pending = readable_events (0);
3450 if (FRAME_LIVE_P (XFRAME (event->frame_or_window)))
3451 x_activate_menubar (XFRAME (event->frame_or_window));
3453 #endif
3454 #ifdef WINDOWSNT
3455 else if (event->kind == language_change_event)
3457 /* Make an event (language-change (FRAME CHARSET LCID)). */
3458 obj = Fcons (event->modifiers, Qnil);
3459 obj = Fcons (event->code, Qnil);
3460 obj = Fcons (event->frame_or_window, obj);
3461 obj = Fcons (Qlanguage_change, Fcons (obj, Qnil));
3462 kbd_fetch_ptr = event + 1;
3464 #endif
3465 /* Just discard these, by returning nil.
3466 With MULTI_KBOARD, these events are used as placeholders
3467 when we need to randomly delete events from the queue.
3468 (They shouldn't otherwise be found in the buffer,
3469 but on some machines it appears they do show up
3470 even without MULTI_KBOARD.) */
3471 /* On Windows NT/9X, no_event is used to delete extraneous
3472 mouse events during a popup-menu call. */
3473 else if (event->kind == no_event)
3474 kbd_fetch_ptr = event + 1;
3475 else if (event->kind == HELP_EVENT)
3477 /* There are always two consecutive HELP_EVENTs in the
3478 input queue. */
3479 Lisp_Object object, position, help, frame, window;
3481 xassert (event->code == 0);
3482 frame = event->frame_or_window;
3483 object = event->arg;
3484 position = event->x;
3485 xassert ((event + 1)->code == 1);
3486 help = (event + 1)->arg;
3487 window = (event + 1)->frame_or_window;
3488 if (!WINDOWP (window))
3489 window = Qnil;
3490 obj = Fcons (Qhelp_echo,
3491 list5 (frame, help, window, object, position));
3492 kbd_fetch_ptr = event + 2;
3494 else if (event->kind == FOCUS_IN_EVENT)
3496 /* Notification of a FocusIn event. The frame receiving the
3497 focus is in event->frame_or_window. Generate a
3498 switch-frame event if necessary. */
3499 Lisp_Object frame, focus;
3501 frame = event->frame_or_window;
3502 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
3503 if (FRAMEP (focus))
3504 frame = focus;
3506 if (!EQ (frame, internal_last_event_frame)
3507 && !EQ (frame, selected_frame))
3508 obj = make_lispy_switch_frame (frame);
3509 internal_last_event_frame = frame;
3510 kbd_fetch_ptr = event + 1;
3512 else
3514 /* If this event is on a different frame, return a switch-frame this
3515 time, and leave the event in the queue for next time. */
3516 Lisp_Object frame;
3517 Lisp_Object focus;
3519 frame = event->frame_or_window;
3520 if (CONSP (frame))
3521 frame = XCAR (frame);
3522 else if (WINDOWP (frame))
3523 frame = WINDOW_FRAME (XWINDOW (frame));
3525 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
3526 if (! NILP (focus))
3527 frame = focus;
3529 if (! EQ (frame, internal_last_event_frame)
3530 && !EQ (frame, selected_frame))
3531 obj = make_lispy_switch_frame (frame);
3532 internal_last_event_frame = frame;
3534 /* If we didn't decide to make a switch-frame event, go ahead
3535 and build a real event from the queue entry. */
3537 if (NILP (obj))
3539 int idx;
3541 obj = make_lispy_event (event);
3543 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
3544 /* If this was a menu selection, then set the flag to inhibit
3545 writing to last_nonmenu_event. Don't do this if the event
3546 we're returning is (menu-bar), though; that indicates the
3547 beginning of the menu sequence, and we might as well leave
3548 that as the `event with parameters' for this selection. */
3549 if (used_mouse_menu
3550 && !EQ (event->frame_or_window, event->arg)
3551 && (event->kind == MENU_BAR_EVENT
3552 || event->kind == TOOL_BAR_EVENT))
3553 *used_mouse_menu = 1;
3554 #endif
3556 /* Wipe out this event, to catch bugs. */
3557 event->kind = no_event;
3558 idx = 2 * (event - kbd_buffer);
3559 ASET (kbd_buffer_gcpro, idx, Qnil);
3560 ASET (kbd_buffer_gcpro, idx + 1, Qnil);
3562 kbd_fetch_ptr = event + 1;
3566 #ifdef HAVE_MOUSE
3567 /* Try generating a mouse motion event. */
3568 else if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3570 FRAME_PTR f = some_mouse_moved ();
3571 Lisp_Object bar_window;
3572 enum scroll_bar_part part;
3573 Lisp_Object x, y;
3574 unsigned long time;
3576 *kbp = current_kboard;
3577 /* Note that this uses F to determine which display to look at.
3578 If there is no valid info, it does not store anything
3579 so x remains nil. */
3580 x = Qnil;
3581 (*mouse_position_hook) (&f, 0, &bar_window, &part, &x, &y, &time);
3583 obj = Qnil;
3585 /* Decide if we should generate a switch-frame event. Don't
3586 generate switch-frame events for motion outside of all Emacs
3587 frames. */
3588 if (!NILP (x) && f)
3590 Lisp_Object frame;
3592 frame = FRAME_FOCUS_FRAME (f);
3593 if (NILP (frame))
3594 XSETFRAME (frame, f);
3596 if (! EQ (frame, internal_last_event_frame)
3597 && !EQ (frame, selected_frame))
3598 obj = make_lispy_switch_frame (frame);
3599 internal_last_event_frame = frame;
3602 /* If we didn't decide to make a switch-frame event, go ahead and
3603 return a mouse-motion event. */
3604 if (!NILP (x) && NILP (obj))
3605 obj = make_lispy_movement (f, bar_window, part, x, y, time);
3607 #endif /* HAVE_MOUSE */
3608 else
3609 /* We were promised by the above while loop that there was
3610 something for us to read! */
3611 abort ();
3613 input_pending = readable_events (0);
3615 Vlast_event_frame = internal_last_event_frame;
3617 return (obj);
3620 /* Process any events that are not user-visible,
3621 then return, without reading any user-visible events. */
3623 void
3624 swallow_events (do_display)
3625 int do_display;
3627 int old_timers_run;
3629 while (kbd_fetch_ptr != kbd_store_ptr)
3631 struct input_event *event;
3633 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3634 ? kbd_fetch_ptr
3635 : kbd_buffer);
3637 last_event_timestamp = event->timestamp;
3639 /* These two kinds of events get special handling
3640 and don't actually appear to the command loop. */
3641 if (event->kind == selection_request_event)
3643 #ifdef HAVE_X11
3644 struct input_event copy;
3646 /* Remove it from the buffer before processing it,
3647 since otherwise swallow_events called recursively could see it
3648 and process it again. */
3649 copy = *event;
3650 kbd_fetch_ptr = event + 1;
3651 input_pending = readable_events (0);
3652 x_handle_selection_request (&copy);
3653 #else
3654 /* We're getting selection request events, but we don't have
3655 a window system. */
3656 abort ();
3657 #endif
3660 else if (event->kind == selection_clear_event)
3662 #ifdef HAVE_X11
3663 struct input_event copy;
3665 /* Remove it from the buffer before processing it, */
3666 copy = *event;
3668 kbd_fetch_ptr = event + 1;
3669 input_pending = readable_events (0);
3670 x_handle_selection_clear (&copy);
3671 #else
3672 /* We're getting selection request events, but we don't have
3673 a window system. */
3674 abort ();
3675 #endif
3677 else
3678 break;
3681 old_timers_run = timers_run;
3682 get_input_pending (&input_pending, 1);
3684 if (timers_run != old_timers_run && do_display)
3685 redisplay_preserve_echo_area ();
3688 static EMACS_TIME timer_idleness_start_time;
3690 /* Record the start of when Emacs is idle,
3691 for the sake of running idle-time timers. */
3693 void
3694 timer_start_idle ()
3696 Lisp_Object timers;
3698 /* If we are already in the idle state, do nothing. */
3699 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
3700 return;
3702 EMACS_GET_TIME (timer_idleness_start_time);
3704 /* Mark all idle-time timers as once again candidates for running. */
3705 for (timers = Vtimer_idle_list; CONSP (timers); timers = XCDR (timers))
3707 Lisp_Object timer;
3709 timer = XCAR (timers);
3711 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
3712 continue;
3713 XVECTOR (timer)->contents[0] = Qnil;
3717 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
3719 void
3720 timer_stop_idle ()
3722 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
3725 /* This is only for debugging. */
3726 struct input_event last_timer_event;
3728 /* Check whether a timer has fired. To prevent larger problems we simply
3729 disregard elements that are not proper timers. Do not make a circular
3730 timer list for the time being.
3732 Returns the number of seconds to wait until the next timer fires. If a
3733 timer is triggering now, return zero seconds.
3734 If no timer is active, return -1 seconds.
3736 If a timer is ripe, we run it, with quitting turned off.
3738 DO_IT_NOW is now ignored. It used to mean that we should
3739 run the timer directly instead of queueing a timer-event.
3740 Now we always run timers directly. */
3742 EMACS_TIME
3743 timer_check (do_it_now)
3744 int do_it_now;
3746 EMACS_TIME nexttime;
3747 EMACS_TIME now, idleness_now;
3748 Lisp_Object timers, idle_timers, chosen_timer;
3749 struct gcpro gcpro1, gcpro2, gcpro3;
3751 EMACS_SET_SECS (nexttime, -1);
3752 EMACS_SET_USECS (nexttime, -1);
3754 /* Always consider the ordinary timers. */
3755 timers = Vtimer_list;
3756 /* Consider the idle timers only if Emacs is idle. */
3757 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
3758 idle_timers = Vtimer_idle_list;
3759 else
3760 idle_timers = Qnil;
3761 chosen_timer = Qnil;
3762 GCPRO3 (timers, idle_timers, chosen_timer);
3764 if (CONSP (timers) || CONSP (idle_timers))
3766 EMACS_GET_TIME (now);
3767 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
3768 EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
3771 while (CONSP (timers) || CONSP (idle_timers))
3773 Lisp_Object *vector;
3774 Lisp_Object timer, idle_timer;
3775 EMACS_TIME timer_time, idle_timer_time;
3776 EMACS_TIME difference, timer_difference, idle_timer_difference;
3778 /* Skip past invalid timers and timers already handled. */
3779 if (!NILP (timers))
3781 timer = XCAR (timers);
3782 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
3784 timers = XCDR (timers);
3785 continue;
3787 vector = XVECTOR (timer)->contents;
3789 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
3790 || !INTEGERP (vector[3])
3791 || ! NILP (vector[0]))
3793 timers = XCDR (timers);
3794 continue;
3797 if (!NILP (idle_timers))
3799 timer = XCAR (idle_timers);
3800 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
3802 idle_timers = XCDR (idle_timers);
3803 continue;
3805 vector = XVECTOR (timer)->contents;
3807 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
3808 || !INTEGERP (vector[3])
3809 || ! NILP (vector[0]))
3811 idle_timers = XCDR (idle_timers);
3812 continue;
3816 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
3817 based on the next ordinary timer.
3818 TIMER_DIFFERENCE is the distance in time from NOW to when
3819 this timer becomes ripe (negative if it's already ripe). */
3820 if (!NILP (timers))
3822 timer = XCAR (timers);
3823 vector = XVECTOR (timer)->contents;
3824 EMACS_SET_SECS (timer_time,
3825 (XINT (vector[1]) << 16) | (XINT (vector[2])));
3826 EMACS_SET_USECS (timer_time, XINT (vector[3]));
3827 EMACS_SUB_TIME (timer_difference, timer_time, now);
3830 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
3831 based on the next idle timer. */
3832 if (!NILP (idle_timers))
3834 idle_timer = XCAR (idle_timers);
3835 vector = XVECTOR (idle_timer)->contents;
3836 EMACS_SET_SECS (idle_timer_time,
3837 (XINT (vector[1]) << 16) | (XINT (vector[2])));
3838 EMACS_SET_USECS (idle_timer_time, XINT (vector[3]));
3839 EMACS_SUB_TIME (idle_timer_difference, idle_timer_time, idleness_now);
3842 /* Decide which timer is the next timer,
3843 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
3844 Also step down the list where we found that timer. */
3846 if (! NILP (timers) && ! NILP (idle_timers))
3848 EMACS_TIME temp;
3849 EMACS_SUB_TIME (temp, timer_difference, idle_timer_difference);
3850 if (EMACS_TIME_NEG_P (temp))
3852 chosen_timer = timer;
3853 timers = XCDR (timers);
3854 difference = timer_difference;
3856 else
3858 chosen_timer = idle_timer;
3859 idle_timers = XCDR (idle_timers);
3860 difference = idle_timer_difference;
3863 else if (! NILP (timers))
3865 chosen_timer = timer;
3866 timers = XCDR (timers);
3867 difference = timer_difference;
3869 else
3871 chosen_timer = idle_timer;
3872 idle_timers = XCDR (idle_timers);
3873 difference = idle_timer_difference;
3875 vector = XVECTOR (chosen_timer)->contents;
3877 /* If timer is ripe, run it if it hasn't been run. */
3878 if (EMACS_TIME_NEG_P (difference)
3879 || (EMACS_SECS (difference) == 0
3880 && EMACS_USECS (difference) == 0))
3882 if (NILP (vector[0]))
3884 int was_locked = single_kboard;
3885 int count = specpdl_ptr - specpdl;
3887 /* Mark the timer as triggered to prevent problems if the lisp
3888 code fails to reschedule it right. */
3889 vector[0] = Qt;
3891 specbind (Qinhibit_quit, Qt);
3893 call1 (Qtimer_event_handler, chosen_timer);
3894 timers_run++;
3896 unbind_to (count, Qnil);
3898 /* Resume allowing input from any kboard, if that was true before. */
3899 if (!was_locked)
3900 any_kboard_state ();
3902 /* Since we have handled the event,
3903 we don't need to tell the caller to wake up and do it. */
3906 else
3907 /* When we encounter a timer that is still waiting,
3908 return the amount of time to wait before it is ripe. */
3910 UNGCPRO;
3911 return difference;
3915 /* No timers are pending in the future. */
3916 /* Return 0 if we generated an event, and -1 if not. */
3917 UNGCPRO;
3918 return nexttime;
3921 /* Caches for modify_event_symbol. */
3922 static Lisp_Object accent_key_syms;
3923 static Lisp_Object func_key_syms;
3924 static Lisp_Object mouse_syms;
3925 #ifdef WINDOWSNT
3926 static Lisp_Object mouse_wheel_syms;
3927 #endif
3928 static Lisp_Object drag_n_drop_syms;
3930 /* This is a list of keysym codes for special "accent" characters.
3931 It parallels lispy_accent_keys. */
3933 static int lispy_accent_codes[] =
3935 #ifdef XK_dead_circumflex
3936 XK_dead_circumflex,
3937 #else
3939 #endif
3940 #ifdef XK_dead_grave
3941 XK_dead_grave,
3942 #else
3944 #endif
3945 #ifdef XK_dead_tilde
3946 XK_dead_tilde,
3947 #else
3949 #endif
3950 #ifdef XK_dead_diaeresis
3951 XK_dead_diaeresis,
3952 #else
3954 #endif
3955 #ifdef XK_dead_macron
3956 XK_dead_macron,
3957 #else
3959 #endif
3960 #ifdef XK_dead_degree
3961 XK_dead_degree,
3962 #else
3964 #endif
3965 #ifdef XK_dead_acute
3966 XK_dead_acute,
3967 #else
3969 #endif
3970 #ifdef XK_dead_cedilla
3971 XK_dead_cedilla,
3972 #else
3974 #endif
3975 #ifdef XK_dead_breve
3976 XK_dead_breve,
3977 #else
3979 #endif
3980 #ifdef XK_dead_ogonek
3981 XK_dead_ogonek,
3982 #else
3984 #endif
3985 #ifdef XK_dead_caron
3986 XK_dead_caron,
3987 #else
3989 #endif
3990 #ifdef XK_dead_doubleacute
3991 XK_dead_doubleacute,
3992 #else
3994 #endif
3995 #ifdef XK_dead_abovedot
3996 XK_dead_abovedot,
3997 #else
3999 #endif
4002 /* This is a list of Lisp names for special "accent" characters.
4003 It parallels lispy_accent_codes. */
4005 static char *lispy_accent_keys[] =
4007 "dead-circumflex",
4008 "dead-grave",
4009 "dead-tilde",
4010 "dead-diaeresis",
4011 "dead-macron",
4012 "dead-degree",
4013 "dead-acute",
4014 "dead-cedilla",
4015 "dead-breve",
4016 "dead-ogonek",
4017 "dead-caron",
4018 "dead-doubleacute",
4019 "dead-abovedot",
4022 #ifdef HAVE_NTGUI
4023 #define FUNCTION_KEY_OFFSET 0x0
4025 char *lispy_function_keys[] =
4027 0, /* 0 */
4029 0, /* VK_LBUTTON 0x01 */
4030 0, /* VK_RBUTTON 0x02 */
4031 "cancel", /* VK_CANCEL 0x03 */
4032 0, /* VK_MBUTTON 0x04 */
4034 0, 0, 0, /* 0x05 .. 0x07 */
4036 "backspace", /* VK_BACK 0x08 */
4037 "tab", /* VK_TAB 0x09 */
4039 0, 0, /* 0x0A .. 0x0B */
4041 "clear", /* VK_CLEAR 0x0C */
4042 "return", /* VK_RETURN 0x0D */
4044 0, 0, /* 0x0E .. 0x0F */
4046 0, /* VK_SHIFT 0x10 */
4047 0, /* VK_CONTROL 0x11 */
4048 0, /* VK_MENU 0x12 */
4049 "pause", /* VK_PAUSE 0x13 */
4050 "capslock", /* VK_CAPITAL 0x14 */
4052 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4054 "escape", /* VK_ESCAPE 0x1B */
4056 0, 0, 0, 0, /* 0x1C .. 0x1F */
4058 0, /* VK_SPACE 0x20 */
4059 "prior", /* VK_PRIOR 0x21 */
4060 "next", /* VK_NEXT 0x22 */
4061 "end", /* VK_END 0x23 */
4062 "home", /* VK_HOME 0x24 */
4063 "left", /* VK_LEFT 0x25 */
4064 "up", /* VK_UP 0x26 */
4065 "right", /* VK_RIGHT 0x27 */
4066 "down", /* VK_DOWN 0x28 */
4067 "select", /* VK_SELECT 0x29 */
4068 "print", /* VK_PRINT 0x2A */
4069 "execute", /* VK_EXECUTE 0x2B */
4070 "snapshot", /* VK_SNAPSHOT 0x2C */
4071 "insert", /* VK_INSERT 0x2D */
4072 "delete", /* VK_DELETE 0x2E */
4073 "help", /* VK_HELP 0x2F */
4075 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4077 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4079 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4081 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4083 0, 0, 0, 0, 0, 0, 0, 0, 0,
4084 0, 0, 0, 0, 0, 0, 0, 0, 0,
4085 0, 0, 0, 0, 0, 0, 0, 0,
4087 "lwindow", /* VK_LWIN 0x5B */
4088 "rwindow", /* VK_RWIN 0x5C */
4089 "apps", /* VK_APPS 0x5D */
4091 0, 0, /* 0x5E .. 0x5F */
4093 "kp-0", /* VK_NUMPAD0 0x60 */
4094 "kp-1", /* VK_NUMPAD1 0x61 */
4095 "kp-2", /* VK_NUMPAD2 0x62 */
4096 "kp-3", /* VK_NUMPAD3 0x63 */
4097 "kp-4", /* VK_NUMPAD4 0x64 */
4098 "kp-5", /* VK_NUMPAD5 0x65 */
4099 "kp-6", /* VK_NUMPAD6 0x66 */
4100 "kp-7", /* VK_NUMPAD7 0x67 */
4101 "kp-8", /* VK_NUMPAD8 0x68 */
4102 "kp-9", /* VK_NUMPAD9 0x69 */
4103 "kp-multiply", /* VK_MULTIPLY 0x6A */
4104 "kp-add", /* VK_ADD 0x6B */
4105 "kp-separator", /* VK_SEPARATOR 0x6C */
4106 "kp-subtract", /* VK_SUBTRACT 0x6D */
4107 "kp-decimal", /* VK_DECIMAL 0x6E */
4108 "kp-divide", /* VK_DIVIDE 0x6F */
4109 "f1", /* VK_F1 0x70 */
4110 "f2", /* VK_F2 0x71 */
4111 "f3", /* VK_F3 0x72 */
4112 "f4", /* VK_F4 0x73 */
4113 "f5", /* VK_F5 0x74 */
4114 "f6", /* VK_F6 0x75 */
4115 "f7", /* VK_F7 0x76 */
4116 "f8", /* VK_F8 0x77 */
4117 "f9", /* VK_F9 0x78 */
4118 "f10", /* VK_F10 0x79 */
4119 "f11", /* VK_F11 0x7A */
4120 "f12", /* VK_F12 0x7B */
4121 "f13", /* VK_F13 0x7C */
4122 "f14", /* VK_F14 0x7D */
4123 "f15", /* VK_F15 0x7E */
4124 "f16", /* VK_F16 0x7F */
4125 "f17", /* VK_F17 0x80 */
4126 "f18", /* VK_F18 0x81 */
4127 "f19", /* VK_F19 0x82 */
4128 "f20", /* VK_F20 0x83 */
4129 "f21", /* VK_F21 0x84 */
4130 "f22", /* VK_F22 0x85 */
4131 "f23", /* VK_F23 0x86 */
4132 "f24", /* VK_F24 0x87 */
4134 0, 0, 0, 0, /* 0x88 .. 0x8B */
4135 0, 0, 0, 0, /* 0x8C .. 0x8F */
4137 "kp-numlock", /* VK_NUMLOCK 0x90 */
4138 "scroll", /* VK_SCROLL 0x91 */
4140 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4141 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4142 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4143 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4144 "kp-end", /* VK_NUMPAD_END 0x96 */
4145 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4146 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4147 "kp-up", /* VK_NUMPAD_UP 0x99 */
4148 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4149 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4150 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4151 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4153 0, 0, /* 0x9E .. 0x9F */
4156 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4157 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4158 * No other API or message will distinguish left and right keys this way.
4160 /* 0xA0 .. 0xEF */
4162 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4163 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4165 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4166 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4168 /* 0xF0 .. 0xF5 */
4170 0, 0, 0, 0, 0, 0,
4172 "attn", /* VK_ATTN 0xF6 */
4173 "crsel", /* VK_CRSEL 0xF7 */
4174 "exsel", /* VK_EXSEL 0xF8 */
4175 "ereof", /* VK_EREOF 0xF9 */
4176 "play", /* VK_PLAY 0xFA */
4177 "zoom", /* VK_ZOOM 0xFB */
4178 "noname", /* VK_NONAME 0xFC */
4179 "pa1", /* VK_PA1 0xFD */
4180 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4181 0 /* 0xFF */
4184 #else /* not HAVE_NTGUI */
4186 #ifdef XK_kana_A
4187 static char *lispy_kana_keys[] =
4189 /* X Keysym value */
4190 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4191 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4192 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4193 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4194 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4195 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4196 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4197 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4198 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4199 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4200 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4201 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4202 "kana-i", "kana-u", "kana-e", "kana-o",
4203 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4204 "prolongedsound", "kana-A", "kana-I", "kana-U",
4205 "kana-E", "kana-O", "kana-KA", "kana-KI",
4206 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4207 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4208 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4209 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4210 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4211 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4212 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4213 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4214 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4215 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4216 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4217 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4219 #endif /* XK_kana_A */
4221 #define FUNCTION_KEY_OFFSET 0xff00
4223 /* You'll notice that this table is arranged to be conveniently
4224 indexed by X Windows keysym values. */
4225 static char *lispy_function_keys[] =
4227 /* X Keysym value */
4229 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4230 "backspace", "tab", "linefeed", "clear",
4231 0, "return", 0, 0,
4232 0, 0, 0, "pause", /* 0xff10...1f */
4233 0, 0, 0, 0, 0, 0, 0, "escape",
4234 0, 0, 0, 0,
4235 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4236 "romaji", "hiragana", "katakana", "hiragana-katakana",
4237 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4238 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4239 "eisu-toggle", /* 0xff30...3f */
4240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4243 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4244 "down", "prior", "next", "end",
4245 "begin", 0, 0, 0, 0, 0, 0, 0,
4246 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4247 "print",
4248 "execute",
4249 "insert",
4250 0, /* 0xff64 */
4251 "undo",
4252 "redo",
4253 "menu",
4254 "find",
4255 "cancel",
4256 "help",
4257 "break", /* 0xff6b */
4259 0, 0, 0, 0,
4260 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4261 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4262 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4263 0, 0, 0, 0, 0, 0, 0, 0,
4264 "kp-tab", /* 0xff89 */
4265 0, 0, 0,
4266 "kp-enter", /* 0xff8d */
4267 0, 0, 0,
4268 "kp-f1", /* 0xff91 */
4269 "kp-f2",
4270 "kp-f3",
4271 "kp-f4",
4272 "kp-home", /* 0xff95 */
4273 "kp-left",
4274 "kp-up",
4275 "kp-right",
4276 "kp-down",
4277 "kp-prior", /* kp-page-up */
4278 "kp-next", /* kp-page-down */
4279 "kp-end",
4280 "kp-begin",
4281 "kp-insert",
4282 "kp-delete",
4283 0, /* 0xffa0 */
4284 0, 0, 0, 0, 0, 0, 0, 0, 0,
4285 "kp-multiply", /* 0xffaa */
4286 "kp-add",
4287 "kp-separator",
4288 "kp-subtract",
4289 "kp-decimal",
4290 "kp-divide", /* 0xffaf */
4291 "kp-0", /* 0xffb0 */
4292 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4293 0, /* 0xffba */
4294 0, 0,
4295 "kp-equal", /* 0xffbd */
4296 "f1", /* 0xffbe */ /* IsFunctionKey */
4297 "f2",
4298 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4299 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4300 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4301 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4302 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4303 0, 0, 0, 0, 0, 0, 0, 0,
4304 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4305 0, 0, 0, 0, 0, 0, 0, "delete"
4308 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4309 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4311 static char *iso_lispy_function_keys[] =
4313 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4314 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4315 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4316 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4317 "iso-lefttab", /* 0xfe20 */
4318 "iso-move-line-up", "iso-move-line-down",
4319 "iso-partial-line-up", "iso-partial-line-down",
4320 "iso-partial-space-left", "iso-partial-space-right",
4321 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4322 "iso-release-margin-left", "iso-release-margin-right",
4323 "iso-release-both-margins",
4324 "iso-fast-cursor-left", "iso-fast-cursor-right",
4325 "iso-fast-cursor-up", "iso-fast-cursor-down",
4326 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4327 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4330 #endif /* not HAVE_NTGUI */
4332 Lisp_Object Vlispy_mouse_stem;
4334 #ifdef WINDOWSNT
4335 /* mouse-wheel events are generated by the wheel on devices such as
4336 the MS Intellimouse. The wheel sits in between the left and right
4337 mouse buttons, and is typically used to scroll or zoom the window
4338 underneath the pointer. mouse-wheel events specify the object on
4339 which they operate, and a delta corresponding to the amount and
4340 direction that the wheel is rotated. Clicking the mouse-wheel
4341 generates a mouse-2 event. */
4342 static char *lispy_mouse_wheel_names[] =
4344 "mouse-wheel"
4347 #endif /* WINDOWSNT */
4349 /* drag-n-drop events are generated when a set of selected files are
4350 dragged from another application and dropped onto an Emacs window. */
4351 static char *lispy_drag_n_drop_names[] =
4353 "drag-n-drop"
4356 /* Scroll bar parts. */
4357 Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
4358 Lisp_Object Qup, Qdown, Qbottom, Qend_scroll;
4359 Lisp_Object Qtop, Qratio;
4361 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
4362 Lisp_Object *scroll_bar_parts[] = {
4363 &Qabove_handle, &Qhandle, &Qbelow_handle,
4364 &Qup, &Qdown, &Qtop, &Qbottom, &Qend_scroll, &Qratio
4367 /* User signal events. */
4368 Lisp_Object Qusr1_signal, Qusr2_signal;
4370 Lisp_Object *lispy_user_signals[] =
4372 &Qusr1_signal, &Qusr2_signal
4376 /* A vector, indexed by button number, giving the down-going location
4377 of currently depressed buttons, both scroll bar and non-scroll bar.
4379 The elements have the form
4380 (BUTTON-NUMBER MODIFIER-MASK . REST)
4381 where REST is the cdr of a position as it would be reported in the event.
4383 The make_lispy_event function stores positions here to tell the
4384 difference between click and drag events, and to store the starting
4385 location to be included in drag events. */
4387 static Lisp_Object button_down_location;
4389 /* Information about the most recent up-going button event: Which
4390 button, what location, and what time. */
4392 static int last_mouse_button;
4393 static int last_mouse_x;
4394 static int last_mouse_y;
4395 static unsigned long button_down_time;
4397 /* The maximum time between clicks to make a double-click,
4398 or Qnil to disable double-click detection,
4399 or Qt for no time limit. */
4400 Lisp_Object Vdouble_click_time;
4402 /* The number of clicks in this multiple-click. */
4404 int double_click_count;
4406 /* Given a struct input_event, build the lisp event which represents
4407 it. If EVENT is 0, build a mouse movement event from the mouse
4408 movement buffer, which should have a movement event in it.
4410 Note that events must be passed to this function in the order they
4411 are received; this function stores the location of button presses
4412 in order to build drag events when the button is released. */
4414 static Lisp_Object
4415 make_lispy_event (event)
4416 struct input_event *event;
4418 int i;
4420 switch (SWITCH_ENUM_CAST (event->kind))
4422 /* A simple keystroke. */
4423 case ascii_keystroke:
4425 Lisp_Object lispy_c;
4426 int c = event->code & 0377;
4427 /* Turn ASCII characters into control characters
4428 when proper. */
4429 if (event->modifiers & ctrl_modifier)
4430 c = make_ctrl_char (c);
4432 /* Add in the other modifier bits. We took care of ctrl_modifier
4433 just above, and the shift key was taken care of by the X code,
4434 and applied to control characters by make_ctrl_char. */
4435 c |= (event->modifiers
4436 & (meta_modifier | alt_modifier
4437 | hyper_modifier | super_modifier));
4438 /* Distinguish Shift-SPC from SPC. */
4439 if ((event->code & 0377) == 040
4440 && event->modifiers & shift_modifier)
4441 c |= shift_modifier;
4442 button_down_time = 0;
4443 XSETFASTINT (lispy_c, c);
4444 return lispy_c;
4447 case multibyte_char_keystroke:
4449 Lisp_Object lispy_c;
4451 XSETFASTINT (lispy_c, event->code);
4452 return lispy_c;
4455 /* A function key. The symbol may need to have modifier prefixes
4456 tacked onto it. */
4457 case non_ascii_keystroke:
4458 button_down_time = 0;
4460 for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
4461 if (event->code == lispy_accent_codes[i])
4462 return modify_event_symbol (i,
4463 event->modifiers,
4464 Qfunction_key, Qnil,
4465 lispy_accent_keys, &accent_key_syms,
4466 (sizeof (lispy_accent_keys)
4467 / sizeof (lispy_accent_keys[0])));
4469 /* Handle system-specific keysyms. */
4470 if (event->code & (1 << 28))
4472 /* We need to use an alist rather than a vector as the cache
4473 since we can't make a vector long enuf. */
4474 if (NILP (current_kboard->system_key_syms))
4475 current_kboard->system_key_syms = Fcons (Qnil, Qnil);
4476 return modify_event_symbol (event->code,
4477 event->modifiers,
4478 Qfunction_key,
4479 current_kboard->Vsystem_key_alist,
4480 0, &current_kboard->system_key_syms,
4481 (unsigned)-1);
4484 #ifdef XK_kana_A
4485 if (event->code >= 0x400 && event->code < 0x500)
4486 return modify_event_symbol (event->code - 0x400,
4487 event->modifiers & ~shift_modifier,
4488 Qfunction_key, Qnil,
4489 lispy_kana_keys, &func_key_syms,
4490 (sizeof (lispy_kana_keys)
4491 / sizeof (lispy_kana_keys[0])));
4492 #endif /* XK_kana_A */
4494 #ifdef ISO_FUNCTION_KEY_OFFSET
4495 if (event->code < FUNCTION_KEY_OFFSET
4496 && event->code >= ISO_FUNCTION_KEY_OFFSET)
4497 return modify_event_symbol (event->code - ISO_FUNCTION_KEY_OFFSET,
4498 event->modifiers,
4499 Qfunction_key, Qnil,
4500 iso_lispy_function_keys, &func_key_syms,
4501 (sizeof (iso_lispy_function_keys)
4502 / sizeof (iso_lispy_function_keys[0])));
4503 else
4504 #endif
4505 return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
4506 event->modifiers,
4507 Qfunction_key, Qnil,
4508 lispy_function_keys, &func_key_syms,
4509 (sizeof (lispy_function_keys)
4510 / sizeof (lispy_function_keys[0])));
4512 #ifdef HAVE_MOUSE
4513 /* A mouse click. Figure out where it is, decide whether it's
4514 a press, click or drag, and build the appropriate structure. */
4515 case mouse_click:
4516 #ifndef USE_TOOLKIT_SCROLL_BARS
4517 case scroll_bar_click:
4518 #endif
4520 int button = event->code;
4521 int is_double;
4522 Lisp_Object position;
4523 Lisp_Object *start_pos_ptr;
4524 Lisp_Object start_pos;
4526 /* Build the position as appropriate for this mouse click. */
4527 if (event->kind == mouse_click)
4529 int part;
4530 FRAME_PTR f = XFRAME (event->frame_or_window);
4531 Lisp_Object window;
4532 Lisp_Object posn;
4533 Lisp_Object string_info = Qnil;
4534 int row, column;
4536 /* Ignore mouse events that were made on frame that
4537 have been deleted. */
4538 if (! FRAME_LIVE_P (f))
4539 return Qnil;
4541 /* EVENT->x and EVENT->y are frame-relative pixel
4542 coordinates at this place. Under old redisplay, COLUMN
4543 and ROW are set to frame relative glyph coordinates
4544 which are then used to determine whether this click is
4545 in a menu (non-toolkit version). */
4546 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
4547 &column, &row, NULL, 1);
4549 #ifndef USE_X_TOOLKIT
4550 /* In the non-toolkit version, clicks on the menu bar
4551 are ordinary button events in the event buffer.
4552 Distinguish them, and invoke the menu.
4554 (In the toolkit version, the toolkit handles the menu bar
4555 and Emacs doesn't know about it until after the user
4556 makes a selection.) */
4557 if (row >= 0 && row < FRAME_MENU_BAR_LINES (f)
4558 && (event->modifiers & down_modifier))
4560 Lisp_Object items, item;
4561 int hpos;
4562 int i;
4564 #if 0
4565 /* Activate the menu bar on the down event. If the
4566 up event comes in before the menu code can deal with it,
4567 just ignore it. */
4568 if (! (event->modifiers & down_modifier))
4569 return Qnil;
4570 #endif
4572 /* Find the menu bar item under `column'. */
4573 item = Qnil;
4574 items = FRAME_MENU_BAR_ITEMS (f);
4575 for (i = 0; i < XVECTOR (items)->size; i += 4)
4577 Lisp_Object pos, string;
4578 string = XVECTOR (items)->contents[i + 1];
4579 pos = XVECTOR (items)->contents[i + 3];
4580 if (NILP (string))
4581 break;
4582 if (column >= XINT (pos)
4583 && column < XINT (pos) + XSTRING (string)->size)
4585 item = XVECTOR (items)->contents[i];
4586 break;
4590 /* ELisp manual 2.4b says (x y) are window relative but
4591 code says they are frame-relative. */
4592 position
4593 = Fcons (event->frame_or_window,
4594 Fcons (Qmenu_bar,
4595 Fcons (Fcons (event->x, event->y),
4596 Fcons (make_number (event->timestamp),
4597 Qnil))));
4599 return Fcons (item, Fcons (position, Qnil));
4601 #endif /* not USE_X_TOOLKIT */
4603 /* Set `window' to the window under frame pixel coordinates
4604 event->x/event->y. */
4605 window = window_from_coordinates (f, XINT (event->x),
4606 XINT (event->y), &part, 0);
4608 if (!WINDOWP (window))
4610 window = event->frame_or_window;
4611 posn = Qnil;
4613 else
4615 /* It's a click in window window at frame coordinates
4616 event->x/ event->y. */
4617 struct window *w = XWINDOW (window);
4619 /* Get window relative coordinates. Original code
4620 `rounded' this to glyph boundaries. */
4621 int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
4622 int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
4624 /* Set event coordinates to window-relative coordinates
4625 for constructing the Lisp event below. */
4626 XSETINT (event->x, wx);
4627 XSETINT (event->y, wy);
4629 if (part == 1 || part == 3)
4631 /* Mode line or top line. Look for a string under
4632 the mouse that may have a `local-map' property. */
4633 Lisp_Object string;
4634 int charpos;
4636 posn = part == 1 ? Qmode_line : Qheader_line;
4637 string = mode_line_string (w, wx, wy, part == 1, &charpos);
4638 if (STRINGP (string))
4639 string_info = Fcons (string, make_number (charpos));
4641 else if (part == 2)
4642 posn = Qvertical_line;
4643 else
4644 XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
4647 position
4648 = Fcons (window,
4649 Fcons (posn,
4650 Fcons (Fcons (event->x, event->y),
4651 Fcons (make_number (event->timestamp),
4652 (NILP (string_info)
4653 ? Qnil
4654 : Fcons (string_info, Qnil))))));
4656 #ifndef USE_TOOLKIT_SCROLL_BARS
4657 else
4659 /* It's a scrollbar click. */
4660 Lisp_Object window;
4661 Lisp_Object portion_whole;
4662 Lisp_Object part;
4664 window = event->frame_or_window;
4665 portion_whole = Fcons (event->x, event->y);
4666 part = *scroll_bar_parts[(int) event->part];
4668 position
4669 = Fcons (window,
4670 Fcons (Qvertical_scroll_bar,
4671 Fcons (portion_whole,
4672 Fcons (make_number (event->timestamp),
4673 Fcons (part, Qnil)))));
4675 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4677 if (button >= XVECTOR (button_down_location)->size)
4679 button_down_location = larger_vector (button_down_location,
4680 button + 1, Qnil);
4681 mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
4684 start_pos_ptr = &XVECTOR (button_down_location)->contents[button];
4686 start_pos = *start_pos_ptr;
4687 *start_pos_ptr = Qnil;
4689 is_double = (button == last_mouse_button
4690 && XINT (event->x) == last_mouse_x
4691 && XINT (event->y) == last_mouse_y
4692 && button_down_time != 0
4693 && (EQ (Vdouble_click_time, Qt)
4694 || (INTEGERP (Vdouble_click_time)
4695 && ((int)(event->timestamp - button_down_time)
4696 < XINT (Vdouble_click_time)))));
4697 last_mouse_button = button;
4698 last_mouse_x = XINT (event->x);
4699 last_mouse_y = XINT (event->y);
4701 /* If this is a button press, squirrel away the location, so
4702 we can decide later whether it was a click or a drag. */
4703 if (event->modifiers & down_modifier)
4705 if (is_double)
4707 double_click_count++;
4708 event->modifiers |= ((double_click_count > 2)
4709 ? triple_modifier
4710 : double_modifier);
4712 else
4713 double_click_count = 1;
4714 button_down_time = event->timestamp;
4715 *start_pos_ptr = Fcopy_alist (position);
4718 /* Now we're releasing a button - check the co-ordinates to
4719 see if this was a click or a drag. */
4720 else if (event->modifiers & up_modifier)
4722 /* If we did not see a down before this up,
4723 ignore the up. Probably this happened because
4724 the down event chose a menu item.
4725 It would be an annoyance to treat the release
4726 of the button that chose the menu item
4727 as a separate event. */
4729 if (!CONSP (start_pos))
4730 return Qnil;
4732 event->modifiers &= ~up_modifier;
4733 #if 0 /* Formerly we treated an up with no down as a click event. */
4734 if (!CONSP (start_pos))
4735 event->modifiers |= click_modifier;
4736 else
4737 #endif
4739 /* The third element of every position should be the (x,y)
4740 pair. */
4741 Lisp_Object down;
4743 down = Fnth (make_number (2), start_pos);
4744 if (EQ (event->x, XCAR (down))
4745 && EQ (event->y, XCDR (down)))
4747 event->modifiers |= click_modifier;
4749 else
4751 button_down_time = 0;
4752 event->modifiers |= drag_modifier;
4754 /* Don't check is_double; treat this as multiple
4755 if the down-event was multiple. */
4756 if (double_click_count > 1)
4757 event->modifiers |= ((double_click_count > 2)
4758 ? triple_modifier
4759 : double_modifier);
4762 else
4763 /* Every mouse event should either have the down_modifier or
4764 the up_modifier set. */
4765 abort ();
4768 /* Get the symbol we should use for the mouse click. */
4769 Lisp_Object head;
4771 head = modify_event_symbol (button,
4772 event->modifiers,
4773 Qmouse_click, Vlispy_mouse_stem,
4774 NULL,
4775 &mouse_syms,
4776 XVECTOR (mouse_syms)->size);
4777 if (event->modifiers & drag_modifier)
4778 return Fcons (head,
4779 Fcons (start_pos,
4780 Fcons (position,
4781 Qnil)));
4782 else if (event->modifiers & (double_modifier | triple_modifier))
4783 return Fcons (head,
4784 Fcons (position,
4785 Fcons (make_number (double_click_count),
4786 Qnil)));
4787 else
4788 return Fcons (head,
4789 Fcons (position,
4790 Qnil));
4794 #if USE_TOOLKIT_SCROLL_BARS
4796 /* We don't have down and up events if using toolkit scroll bars,
4797 so make this always a click event. Store in the `part' of
4798 the Lisp event a symbol which maps to the following actions:
4800 `above_handle' page up
4801 `below_handle' page down
4802 `up' line up
4803 `down' line down
4804 `top' top of buffer
4805 `bottom' bottom of buffer
4806 `handle' thumb has been dragged.
4807 `end-scroll' end of interaction with scroll bar
4809 The incoming input_event contains in its `part' member an
4810 index of type `enum scroll_bar_part' which we can use as an
4811 index in scroll_bar_parts to get the appropriate symbol. */
4813 case scroll_bar_click:
4815 Lisp_Object position, head, window, portion_whole, part;
4817 window = event->frame_or_window;
4818 portion_whole = Fcons (event->x, event->y);
4819 part = *scroll_bar_parts[(int) event->part];
4821 position
4822 = Fcons (window,
4823 Fcons (Qvertical_scroll_bar,
4824 Fcons (portion_whole,
4825 Fcons (make_number (event->timestamp),
4826 Fcons (part, Qnil)))));
4828 /* Always treat scroll bar events as clicks. */
4829 event->modifiers |= click_modifier;
4831 /* Get the symbol we should use for the mouse click. */
4832 head = modify_event_symbol (event->code,
4833 event->modifiers,
4834 Qmouse_click,
4835 Vlispy_mouse_stem,
4836 NULL, &mouse_syms,
4837 XVECTOR (mouse_syms)->size);
4838 return Fcons (head, Fcons (position, Qnil));
4841 #endif /* USE_TOOLKIT_SCROLL_BARS */
4843 #ifdef WINDOWSNT
4844 case w32_scroll_bar_click:
4846 int button = event->code;
4847 int is_double;
4848 Lisp_Object position;
4849 Lisp_Object *start_pos_ptr;
4850 Lisp_Object start_pos;
4853 Lisp_Object window;
4854 Lisp_Object portion_whole;
4855 Lisp_Object part;
4857 window = event->frame_or_window;
4858 portion_whole = Fcons (event->x, event->y);
4859 part = *scroll_bar_parts[(int) event->part];
4861 position
4862 = Fcons (window,
4863 Fcons (Qvertical_scroll_bar,
4864 Fcons (portion_whole,
4865 Fcons (make_number (event->timestamp),
4866 Fcons (part, Qnil)))));
4869 /* Always treat W32 scroll bar events as clicks. */
4870 event->modifiers |= click_modifier;
4873 /* Get the symbol we should use for the mouse click. */
4874 Lisp_Object head;
4876 head = modify_event_symbol (button,
4877 event->modifiers,
4878 Qmouse_click,
4879 Vlispy_mouse_stem,
4880 NULL, &mouse_syms,
4881 XVECTOR (mouse_syms)->size);
4882 return Fcons (head,
4883 Fcons (position,
4884 Qnil));
4887 case mouse_wheel:
4889 int part;
4890 FRAME_PTR f = XFRAME (event->frame_or_window);
4891 Lisp_Object window;
4892 Lisp_Object posn;
4893 Lisp_Object head, position;
4894 int row, column;
4896 /* Ignore mouse events that were made on frame that
4897 have been deleted. */
4898 if (! FRAME_LIVE_P (f))
4899 return Qnil;
4900 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
4901 &column, &row, NULL, 1);
4902 window = window_from_coordinates (f, column, row, &part, 0);
4904 if (!WINDOWP (window))
4906 window = event->frame_or_window;
4907 posn = Qnil;
4909 else
4911 int pixcolumn, pixrow;
4912 column -= XINT (XWINDOW (window)->left);
4913 row -= XINT (XWINDOW (window)->top);
4914 glyph_to_pixel_coords (XWINDOW(window), column, row,
4915 &pixcolumn, &pixrow);
4916 XSETINT (event->x, pixcolumn);
4917 XSETINT (event->y, pixrow);
4919 if (part == 1)
4920 posn = Qmode_line;
4921 else if (part == 2)
4922 posn = Qvertical_line;
4923 else if (part == 3)
4924 posn = Qheader_line;
4925 else
4926 XSETINT (posn,
4927 buffer_posn_from_coords (XWINDOW (window),
4928 &column, &row));
4932 Lisp_Object head, position;
4934 position
4935 = Fcons (window,
4936 Fcons (posn,
4937 Fcons (Fcons (event->x, event->y),
4938 Fcons (make_number (event->timestamp),
4939 Qnil))));
4941 head = modify_event_symbol (0, event->modifiers,
4942 Qmouse_wheel, Qnil,
4943 lispy_mouse_wheel_names,
4944 &mouse_wheel_syms, 1);
4945 return Fcons (head,
4946 Fcons (position,
4947 Fcons (make_number (event->code),
4948 Qnil)));
4951 #endif /* WINDOWSNT */
4953 case drag_n_drop:
4955 int part;
4956 FRAME_PTR f;
4957 Lisp_Object window;
4958 Lisp_Object posn;
4959 Lisp_Object files;
4960 int row, column;
4962 /* The frame_or_window field should be a cons of the frame in
4963 which the event occurred and a list of the filenames
4964 dropped. */
4965 if (! CONSP (event->frame_or_window))
4966 abort ();
4968 f = XFRAME (XCAR (event->frame_or_window));
4969 files = XCDR (event->frame_or_window);
4971 /* Ignore mouse events that were made on frames that
4972 have been deleted. */
4973 if (! FRAME_LIVE_P (f))
4974 return Qnil;
4975 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
4976 &column, &row, NULL, 1);
4977 window = window_from_coordinates (f, column, row, &part, 0);
4979 if (!WINDOWP (window))
4981 window = XCAR (event->frame_or_window);
4982 posn = Qnil;
4984 else
4986 /* It's an event in window `window' at frame coordinates
4987 event->x/ event->y. */
4988 struct window *w = XWINDOW (window);
4990 /* Get window relative coordinates. */
4991 int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
4992 int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
4994 /* Set event coordinates to window-relative coordinates
4995 for constructing the Lisp event below. */
4996 XSETINT (event->x, wx);
4997 XSETINT (event->y, wy);
4999 if (part == 1)
5000 posn = Qmode_line;
5001 else if (part == 2)
5002 posn = Qvertical_line;
5003 else if (part == 3)
5004 posn = Qheader_line;
5005 else
5006 XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
5010 Lisp_Object head, position;
5012 position
5013 = Fcons (window,
5014 Fcons (posn,
5015 Fcons (Fcons (event->x, event->y),
5016 Fcons (make_number (event->timestamp),
5017 Qnil))));
5019 head = modify_event_symbol (0, event->modifiers,
5020 Qdrag_n_drop, Qnil,
5021 lispy_drag_n_drop_names,
5022 &drag_n_drop_syms, 1);
5023 return Fcons (head,
5024 Fcons (position,
5025 Fcons (files,
5026 Qnil)));
5029 #endif /* HAVE_MOUSE */
5031 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
5032 case MENU_BAR_EVENT:
5033 if (EQ (event->arg, event->frame_or_window))
5034 /* This is the prefix key. We translate this to
5035 `(menu_bar)' because the code in keyboard.c for menu
5036 events, which we use, relies on this. */
5037 return Fcons (Qmenu_bar, Qnil);
5038 return event->arg;
5039 #endif
5041 case TOOL_BAR_EVENT:
5042 if (EQ (event->arg, event->frame_or_window))
5043 /* This is the prefix key. We translate this to
5044 `(tool_bar)' because the code in keyboard.c for menu
5045 events, which we use, relies on this. */
5046 return Fcons (Qtool_bar, Qnil);
5047 else if (SYMBOLP (event->arg))
5048 return apply_modifiers (event->modifiers, event->arg);
5049 return event->arg;
5051 case USER_SIGNAL_EVENT:
5052 /* A user signal. */
5053 return *lispy_user_signals[event->code];
5055 /* The 'kind' field of the event is something we don't recognize. */
5056 default:
5057 abort ();
5061 #ifdef HAVE_MOUSE
5063 static Lisp_Object
5064 make_lispy_movement (frame, bar_window, part, x, y, time)
5065 FRAME_PTR frame;
5066 Lisp_Object bar_window;
5067 enum scroll_bar_part part;
5068 Lisp_Object x, y;
5069 unsigned long time;
5071 /* Is it a scroll bar movement? */
5072 if (frame && ! NILP (bar_window))
5074 Lisp_Object part_sym;
5076 part_sym = *scroll_bar_parts[(int) part];
5077 return Fcons (Qscroll_bar_movement,
5078 (Fcons (Fcons (bar_window,
5079 Fcons (Qvertical_scroll_bar,
5080 Fcons (Fcons (x, y),
5081 Fcons (make_number (time),
5082 Fcons (part_sym,
5083 Qnil))))),
5084 Qnil)));
5087 /* Or is it an ordinary mouse movement? */
5088 else
5090 int area;
5091 Lisp_Object window;
5092 Lisp_Object posn;
5094 if (frame)
5095 /* It's in a frame; which window on that frame? */
5096 window = window_from_coordinates (frame, XINT (x), XINT (y), &area, 0);
5097 else
5098 window = Qnil;
5100 if (WINDOWP (window))
5102 struct window *w = XWINDOW (window);
5103 int wx, wy;
5105 /* Get window relative coordinates. */
5106 wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (x));
5107 wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (y));
5108 XSETINT (x, wx);
5109 XSETINT (y, wy);
5111 if (area == 1)
5112 posn = Qmode_line;
5113 else if (area == 2)
5114 posn = Qvertical_line;
5115 else if (area == 3)
5116 posn = Qheader_line;
5117 else
5118 XSETINT (posn, buffer_posn_from_coords (w, &wx, &wy));
5120 else if (frame != 0)
5122 XSETFRAME (window, frame);
5123 posn = Qnil;
5125 else
5127 window = Qnil;
5128 posn = Qnil;
5129 XSETFASTINT (x, 0);
5130 XSETFASTINT (y, 0);
5133 return Fcons (Qmouse_movement,
5134 Fcons (Fcons (window,
5135 Fcons (posn,
5136 Fcons (Fcons (x, y),
5137 Fcons (make_number (time),
5138 Qnil)))),
5139 Qnil));
5143 #endif /* HAVE_MOUSE */
5145 /* Construct a switch frame event. */
5146 static Lisp_Object
5147 make_lispy_switch_frame (frame)
5148 Lisp_Object frame;
5150 return Fcons (Qswitch_frame, Fcons (frame, Qnil));
5153 /* Manipulating modifiers. */
5155 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5157 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5158 SYMBOL's name of the end of the modifiers; the string from this
5159 position is the unmodified symbol name.
5161 This doesn't use any caches. */
5163 static int
5164 parse_modifiers_uncached (symbol, modifier_end)
5165 Lisp_Object symbol;
5166 int *modifier_end;
5168 struct Lisp_String *name;
5169 int i;
5170 int modifiers;
5172 CHECK_SYMBOL (symbol, 1);
5174 modifiers = 0;
5175 name = XSYMBOL (symbol)->name;
5177 for (i = 0; i+2 <= STRING_BYTES (name); )
5179 int this_mod_end = 0;
5180 int this_mod = 0;
5182 /* See if the name continues with a modifier word.
5183 Check that the word appears, but don't check what follows it.
5184 Set this_mod and this_mod_end to record what we find. */
5186 switch (name->data[i])
5188 #define SINGLE_LETTER_MOD(BIT) \
5189 (this_mod_end = i + 1, this_mod = BIT)
5191 case 'A':
5192 SINGLE_LETTER_MOD (alt_modifier);
5193 break;
5195 case 'C':
5196 SINGLE_LETTER_MOD (ctrl_modifier);
5197 break;
5199 case 'H':
5200 SINGLE_LETTER_MOD (hyper_modifier);
5201 break;
5203 case 'M':
5204 SINGLE_LETTER_MOD (meta_modifier);
5205 break;
5207 case 'S':
5208 SINGLE_LETTER_MOD (shift_modifier);
5209 break;
5211 case 's':
5212 SINGLE_LETTER_MOD (super_modifier);
5213 break;
5215 #undef SINGLE_LETTER_MOD
5218 /* If we found no modifier, stop looking for them. */
5219 if (this_mod_end == 0)
5220 break;
5222 /* Check there is a dash after the modifier, so that it
5223 really is a modifier. */
5224 if (this_mod_end >= STRING_BYTES (name)
5225 || name->data[this_mod_end] != '-')
5226 break;
5228 /* This modifier is real; look for another. */
5229 modifiers |= this_mod;
5230 i = this_mod_end + 1;
5233 /* Should we include the `click' modifier? */
5234 if (! (modifiers & (down_modifier | drag_modifier
5235 | double_modifier | triple_modifier))
5236 && i + 7 == STRING_BYTES (name)
5237 && strncmp (name->data + i, "mouse-", 6) == 0
5238 && ('0' <= name->data[i + 6] && name->data[i + 6] <= '9'))
5239 modifiers |= click_modifier;
5241 if (modifier_end)
5242 *modifier_end = i;
5244 return modifiers;
5247 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5248 prepended to the string BASE[0..BASE_LEN-1].
5249 This doesn't use any caches. */
5250 static Lisp_Object
5251 apply_modifiers_uncached (modifiers, base, base_len, base_len_byte)
5252 int modifiers;
5253 char *base;
5254 int base_len, base_len_byte;
5256 /* Since BASE could contain nulls, we can't use intern here; we have
5257 to use Fintern, which expects a genuine Lisp_String, and keeps a
5258 reference to it. */
5259 char *new_mods
5260 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
5261 int mod_len;
5264 char *p = new_mods;
5266 /* Only the event queue may use the `up' modifier; it should always
5267 be turned into a click or drag event before presented to lisp code. */
5268 if (modifiers & up_modifier)
5269 abort ();
5271 if (modifiers & alt_modifier) { *p++ = 'A'; *p++ = '-'; }
5272 if (modifiers & ctrl_modifier) { *p++ = 'C'; *p++ = '-'; }
5273 if (modifiers & hyper_modifier) { *p++ = 'H'; *p++ = '-'; }
5274 if (modifiers & meta_modifier) { *p++ = 'M'; *p++ = '-'; }
5275 if (modifiers & shift_modifier) { *p++ = 'S'; *p++ = '-'; }
5276 if (modifiers & super_modifier) { *p++ = 's'; *p++ = '-'; }
5277 if (modifiers & double_modifier) { strcpy (p, "double-"); p += 7; }
5278 if (modifiers & triple_modifier) { strcpy (p, "triple-"); p += 7; }
5279 if (modifiers & down_modifier) { strcpy (p, "down-"); p += 5; }
5280 if (modifiers & drag_modifier) { strcpy (p, "drag-"); p += 5; }
5281 /* The click modifier is denoted by the absence of other modifiers. */
5283 *p = '\0';
5285 mod_len = p - new_mods;
5289 Lisp_Object new_name;
5291 new_name = make_uninit_multibyte_string (mod_len + base_len,
5292 mod_len + base_len_byte);
5293 bcopy (new_mods, XSTRING (new_name)->data, mod_len);
5294 bcopy (base, XSTRING (new_name)->data + mod_len, base_len_byte);
5296 return Fintern (new_name, Qnil);
5301 static char *modifier_names[] =
5303 "up", "down", "drag", "click", "double", "triple", 0, 0,
5304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5305 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
5307 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
5309 static Lisp_Object modifier_symbols;
5311 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
5312 static Lisp_Object
5313 lispy_modifier_list (modifiers)
5314 int modifiers;
5316 Lisp_Object modifier_list;
5317 int i;
5319 modifier_list = Qnil;
5320 for (i = 0; (1<<i) <= modifiers && i < NUM_MOD_NAMES; i++)
5321 if (modifiers & (1<<i))
5322 modifier_list = Fcons (XVECTOR (modifier_symbols)->contents[i],
5323 modifier_list);
5325 return modifier_list;
5329 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
5330 where UNMODIFIED is the unmodified form of SYMBOL,
5331 MASK is the set of modifiers present in SYMBOL's name.
5332 This is similar to parse_modifiers_uncached, but uses the cache in
5333 SYMBOL's Qevent_symbol_element_mask property, and maintains the
5334 Qevent_symbol_elements property. */
5336 Lisp_Object
5337 parse_modifiers (symbol)
5338 Lisp_Object symbol;
5340 Lisp_Object elements;
5342 elements = Fget (symbol, Qevent_symbol_element_mask);
5343 if (CONSP (elements))
5344 return elements;
5345 else
5347 int end;
5348 int modifiers = parse_modifiers_uncached (symbol, &end);
5349 Lisp_Object unmodified;
5350 Lisp_Object mask;
5352 unmodified = Fintern (make_string (XSYMBOL (symbol)->name->data + end,
5353 STRING_BYTES (XSYMBOL (symbol)->name) - end),
5354 Qnil);
5356 if (modifiers & ~(((EMACS_INT)1 << VALBITS) - 1))
5357 abort ();
5358 XSETFASTINT (mask, modifiers);
5359 elements = Fcons (unmodified, Fcons (mask, Qnil));
5361 /* Cache the parsing results on SYMBOL. */
5362 Fput (symbol, Qevent_symbol_element_mask,
5363 elements);
5364 Fput (symbol, Qevent_symbol_elements,
5365 Fcons (unmodified, lispy_modifier_list (modifiers)));
5367 /* Since we know that SYMBOL is modifiers applied to unmodified,
5368 it would be nice to put that in unmodified's cache.
5369 But we can't, since we're not sure that parse_modifiers is
5370 canonical. */
5372 return elements;
5376 /* Apply the modifiers MODIFIERS to the symbol BASE.
5377 BASE must be unmodified.
5379 This is like apply_modifiers_uncached, but uses BASE's
5380 Qmodifier_cache property, if present. It also builds
5381 Qevent_symbol_elements properties, since it has that info anyway.
5383 apply_modifiers copies the value of BASE's Qevent_kind property to
5384 the modified symbol. */
5385 static Lisp_Object
5386 apply_modifiers (modifiers, base)
5387 int modifiers;
5388 Lisp_Object base;
5390 Lisp_Object cache, index, entry, new_symbol;
5392 /* Mask out upper bits. We don't know where this value's been. */
5393 modifiers &= ((EMACS_INT)1 << VALBITS) - 1;
5395 /* The click modifier never figures into cache indices. */
5396 cache = Fget (base, Qmodifier_cache);
5397 XSETFASTINT (index, (modifiers & ~click_modifier));
5398 entry = assq_no_quit (index, cache);
5400 if (CONSP (entry))
5401 new_symbol = XCDR (entry);
5402 else
5404 /* We have to create the symbol ourselves. */
5405 new_symbol = apply_modifiers_uncached (modifiers,
5406 XSYMBOL (base)->name->data,
5407 XSYMBOL (base)->name->size,
5408 STRING_BYTES (XSYMBOL (base)->name));
5410 /* Add the new symbol to the base's cache. */
5411 entry = Fcons (index, new_symbol);
5412 Fput (base, Qmodifier_cache, Fcons (entry, cache));
5414 /* We have the parsing info now for free, so add it to the caches. */
5415 XSETFASTINT (index, modifiers);
5416 Fput (new_symbol, Qevent_symbol_element_mask,
5417 Fcons (base, Fcons (index, Qnil)));
5418 Fput (new_symbol, Qevent_symbol_elements,
5419 Fcons (base, lispy_modifier_list (modifiers)));
5422 /* Make sure this symbol is of the same kind as BASE.
5424 You'd think we could just set this once and for all when we
5425 intern the symbol above, but reorder_modifiers may call us when
5426 BASE's property isn't set right; we can't assume that just
5427 because it has a Qmodifier_cache property it must have its
5428 Qevent_kind set right as well. */
5429 if (NILP (Fget (new_symbol, Qevent_kind)))
5431 Lisp_Object kind;
5433 kind = Fget (base, Qevent_kind);
5434 if (! NILP (kind))
5435 Fput (new_symbol, Qevent_kind, kind);
5438 return new_symbol;
5442 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
5443 return a symbol with the modifiers placed in the canonical order.
5444 Canonical order is alphabetical, except for down and drag, which
5445 always come last. The 'click' modifier is never written out.
5447 Fdefine_key calls this to make sure that (for example) C-M-foo
5448 and M-C-foo end up being equivalent in the keymap. */
5450 Lisp_Object
5451 reorder_modifiers (symbol)
5452 Lisp_Object symbol;
5454 /* It's hopefully okay to write the code this way, since everything
5455 will soon be in caches, and no consing will be done at all. */
5456 Lisp_Object parsed;
5458 parsed = parse_modifiers (symbol);
5459 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed))),
5460 XCAR (parsed));
5464 /* For handling events, we often want to produce a symbol whose name
5465 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
5466 to some base, like the name of a function key or mouse button.
5467 modify_event_symbol produces symbols of this sort.
5469 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
5470 is the name of the i'th symbol. TABLE_SIZE is the number of elements
5471 in the table.
5473 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
5474 into symbol names, or a string specifying a name stem used to
5475 construct a symbol name or the form `STEM-N', where N is the decimal
5476 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
5477 non-nil; otherwise NAME_TABLE is used.
5479 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
5480 persist between calls to modify_event_symbol that it can use to
5481 store a cache of the symbols it's generated for this NAME_TABLE
5482 before. The object stored there may be a vector or an alist.
5484 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
5486 MODIFIERS is a set of modifier bits (as given in struct input_events)
5487 whose prefixes should be applied to the symbol name.
5489 SYMBOL_KIND is the value to be placed in the event_kind property of
5490 the returned symbol.
5492 The symbols we create are supposed to have an
5493 `event-symbol-elements' property, which lists the modifiers present
5494 in the symbol's name. */
5496 static Lisp_Object
5497 modify_event_symbol (symbol_num, modifiers, symbol_kind, name_alist_or_stem,
5498 name_table, symbol_table, table_size)
5499 int symbol_num;
5500 unsigned modifiers;
5501 Lisp_Object symbol_kind;
5502 Lisp_Object name_alist_or_stem;
5503 char **name_table;
5504 Lisp_Object *symbol_table;
5505 unsigned int table_size;
5507 Lisp_Object value;
5508 Lisp_Object symbol_int;
5510 /* Get rid of the "vendor-specific" bit here. */
5511 XSETINT (symbol_int, symbol_num & 0xffffff);
5513 /* Is this a request for a valid symbol? */
5514 if (symbol_num < 0 || symbol_num >= table_size)
5515 return Qnil;
5517 if (CONSP (*symbol_table))
5518 value = Fcdr (assq_no_quit (symbol_int, *symbol_table));
5520 /* If *symbol_table doesn't seem to be initialized properly, fix that.
5521 *symbol_table should be a lisp vector TABLE_SIZE elements long,
5522 where the Nth element is the symbol for NAME_TABLE[N], or nil if
5523 we've never used that symbol before. */
5524 else
5526 if (! VECTORP (*symbol_table)
5527 || XVECTOR (*symbol_table)->size != table_size)
5529 Lisp_Object size;
5531 XSETFASTINT (size, table_size);
5532 *symbol_table = Fmake_vector (size, Qnil);
5535 value = XVECTOR (*symbol_table)->contents[symbol_num];
5538 /* Have we already used this symbol before? */
5539 if (NILP (value))
5541 /* No; let's create it. */
5542 if (CONSP (name_alist_or_stem))
5543 value = Fcdr_safe (Fassq (symbol_int, name_alist_or_stem));
5544 else if (STRINGP (name_alist_or_stem))
5546 int len = STRING_BYTES (XSTRING (name_alist_or_stem));
5547 char *buf = (char *) alloca (len + 50);
5548 sprintf (buf, "%s-%d", XSTRING (name_alist_or_stem)->data,
5549 XINT (symbol_int) + 1);
5550 value = intern (buf);
5552 else if (name_table != 0 && name_table[symbol_num])
5553 value = intern (name_table[symbol_num]);
5555 #ifdef HAVE_WINDOW_SYSTEM
5556 if (NILP (value))
5558 char *name = x_get_keysym_name (symbol_num);
5559 if (name)
5560 value = intern (name);
5562 #endif
5564 if (NILP (value))
5566 char buf[20];
5567 sprintf (buf, "key-%d", symbol_num);
5568 value = intern (buf);
5571 if (CONSP (*symbol_table))
5572 *symbol_table = Fcons (Fcons (symbol_int, value), *symbol_table);
5573 else
5574 XVECTOR (*symbol_table)->contents[symbol_num] = value;
5576 /* Fill in the cache entries for this symbol; this also
5577 builds the Qevent_symbol_elements property, which the user
5578 cares about. */
5579 apply_modifiers (modifiers & click_modifier, value);
5580 Fput (value, Qevent_kind, symbol_kind);
5583 /* Apply modifiers to that symbol. */
5584 return apply_modifiers (modifiers, value);
5587 /* Convert a list that represents an event type,
5588 such as (ctrl meta backspace), into the usual representation of that
5589 event type as a number or a symbol. */
5591 DEFUN ("event-convert-list", Fevent_convert_list, Sevent_convert_list, 1, 1, 0,
5592 "Convert the event description list EVENT-DESC to an event type.\n\
5593 EVENT-DESC should contain one base event type (a character or symbol)\n\
5594 and zero or more modifier names (control, meta, hyper, super, shift, alt,\n\
5595 drag, down, double or triple). The base must be last.\n\
5596 The return value is an event type (a character or symbol) which\n\
5597 has the same base event type and all the specified modifiers.")
5598 (event_desc)
5599 Lisp_Object event_desc;
5601 Lisp_Object base;
5602 int modifiers = 0;
5603 Lisp_Object rest;
5605 base = Qnil;
5606 rest = event_desc;
5607 while (CONSP (rest))
5609 Lisp_Object elt;
5610 int this = 0;
5612 elt = XCAR (rest);
5613 rest = XCDR (rest);
5615 /* Given a symbol, see if it is a modifier name. */
5616 if (SYMBOLP (elt) && CONSP (rest))
5617 this = parse_solitary_modifier (elt);
5619 if (this != 0)
5620 modifiers |= this;
5621 else if (!NILP (base))
5622 error ("Two bases given in one event");
5623 else
5624 base = elt;
5628 /* Let the symbol A refer to the character A. */
5629 if (SYMBOLP (base) && XSYMBOL (base)->name->size == 1)
5630 XSETINT (base, XSYMBOL (base)->name->data[0]);
5632 if (INTEGERP (base))
5634 /* Turn (shift a) into A. */
5635 if ((modifiers & shift_modifier) != 0
5636 && (XINT (base) >= 'a' && XINT (base) <= 'z'))
5638 XSETINT (base, XINT (base) - ('a' - 'A'));
5639 modifiers &= ~shift_modifier;
5642 /* Turn (control a) into C-a. */
5643 if (modifiers & ctrl_modifier)
5644 return make_number ((modifiers & ~ctrl_modifier)
5645 | make_ctrl_char (XINT (base)));
5646 else
5647 return make_number (modifiers | XINT (base));
5649 else if (SYMBOLP (base))
5650 return apply_modifiers (modifiers, base);
5651 else
5652 error ("Invalid base event");
5655 /* Try to recognize SYMBOL as a modifier name.
5656 Return the modifier flag bit, or 0 if not recognized. */
5658 static int
5659 parse_solitary_modifier (symbol)
5660 Lisp_Object symbol;
5662 struct Lisp_String *name = XSYMBOL (symbol)->name;
5664 switch (name->data[0])
5666 #define SINGLE_LETTER_MOD(BIT) \
5667 if (STRING_BYTES (name) == 1) \
5668 return BIT;
5670 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
5671 if (LEN == STRING_BYTES (name) \
5672 && ! strncmp (name->data, NAME, LEN)) \
5673 return BIT;
5675 case 'A':
5676 SINGLE_LETTER_MOD (alt_modifier);
5677 break;
5679 case 'a':
5680 MULTI_LETTER_MOD (alt_modifier, "alt", 3);
5681 break;
5683 case 'C':
5684 SINGLE_LETTER_MOD (ctrl_modifier);
5685 break;
5687 case 'c':
5688 MULTI_LETTER_MOD (ctrl_modifier, "ctrl", 4);
5689 MULTI_LETTER_MOD (ctrl_modifier, "control", 7);
5690 break;
5692 case 'H':
5693 SINGLE_LETTER_MOD (hyper_modifier);
5694 break;
5696 case 'h':
5697 MULTI_LETTER_MOD (hyper_modifier, "hyper", 5);
5698 break;
5700 case 'M':
5701 SINGLE_LETTER_MOD (meta_modifier);
5702 break;
5704 case 'm':
5705 MULTI_LETTER_MOD (meta_modifier, "meta", 4);
5706 break;
5708 case 'S':
5709 SINGLE_LETTER_MOD (shift_modifier);
5710 break;
5712 case 's':
5713 MULTI_LETTER_MOD (shift_modifier, "shift", 5);
5714 MULTI_LETTER_MOD (super_modifier, "super", 5);
5715 SINGLE_LETTER_MOD (super_modifier);
5716 break;
5718 case 'd':
5719 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
5720 MULTI_LETTER_MOD (down_modifier, "down", 4);
5721 MULTI_LETTER_MOD (double_modifier, "double", 6);
5722 break;
5724 case 't':
5725 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
5726 break;
5728 #undef SINGLE_LETTER_MOD
5729 #undef MULTI_LETTER_MOD
5732 return 0;
5735 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
5736 Such a list is not valid as an event,
5737 but it can be a Lucid-style event type list. */
5740 lucid_event_type_list_p (object)
5741 Lisp_Object object;
5743 Lisp_Object tail;
5745 if (! CONSP (object))
5746 return 0;
5748 for (tail = object; CONSP (tail); tail = XCDR (tail))
5750 Lisp_Object elt;
5751 elt = XCAR (tail);
5752 if (! (INTEGERP (elt) || SYMBOLP (elt)))
5753 return 0;
5756 return NILP (tail);
5759 /* Store into *addr a value nonzero if terminal input chars are available.
5760 Serves the purpose of ioctl (0, FIONREAD, addr)
5761 but works even if FIONREAD does not exist.
5762 (In fact, this may actually read some input.)
5764 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
5766 static void
5767 get_input_pending (addr, do_timers_now)
5768 int *addr;
5769 int do_timers_now;
5771 /* First of all, have we already counted some input? */
5772 *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
5774 /* If input is being read as it arrives, and we have none, there is none. */
5775 if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
5776 return;
5778 /* Try to read some input and see how much we get. */
5779 gobble_input (0);
5780 *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
5783 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
5785 void
5786 gobble_input (expected)
5787 int expected;
5789 #ifndef VMS
5790 #ifdef SIGIO
5791 if (interrupt_input)
5793 SIGMASKTYPE mask;
5794 mask = sigblock (sigmask (SIGIO));
5795 read_avail_input (expected);
5796 sigsetmask (mask);
5798 else
5799 #ifdef POLL_FOR_INPUT
5800 if (read_socket_hook && !interrupt_input && poll_suppress_count == 0)
5802 SIGMASKTYPE mask;
5803 mask = sigblock (sigmask (SIGALRM));
5804 read_avail_input (expected);
5805 sigsetmask (mask);
5807 else
5808 #endif
5809 #endif
5810 read_avail_input (expected);
5811 #endif
5814 /* Put a buffer_switch_event in the buffer
5815 so that read_key_sequence will notice the new current buffer. */
5817 void
5818 record_asynch_buffer_change ()
5820 struct input_event event;
5821 Lisp_Object tem;
5823 event.kind = buffer_switch_event;
5824 event.frame_or_window = Qnil;
5825 event.arg = Qnil;
5827 #ifdef subprocesses
5828 /* We don't need a buffer-switch event unless Emacs is waiting for input.
5829 The purpose of the event is to make read_key_sequence look up the
5830 keymaps again. If we aren't in read_key_sequence, we don't need one,
5831 and the event could cause trouble by messing up (input-pending-p). */
5832 tem = Fwaiting_for_user_input_p ();
5833 if (NILP (tem))
5834 return;
5835 #else
5836 /* We never need these events if we have no asynchronous subprocesses. */
5837 return;
5838 #endif
5840 /* Make sure no interrupt happens while storing the event. */
5841 #ifdef SIGIO
5842 if (interrupt_input)
5844 SIGMASKTYPE mask;
5845 mask = sigblock (sigmask (SIGIO));
5846 kbd_buffer_store_event (&event);
5847 sigsetmask (mask);
5849 else
5850 #endif
5852 stop_polling ();
5853 kbd_buffer_store_event (&event);
5854 start_polling ();
5858 #ifndef VMS
5860 /* Read any terminal input already buffered up by the system
5861 into the kbd_buffer, but do not wait.
5863 EXPECTED should be nonzero if the caller knows there is some input.
5865 Except on VMS, all input is read by this function.
5866 If interrupt_input is nonzero, this function MUST be called
5867 only when SIGIO is blocked.
5869 Returns the number of keyboard chars read, or -1 meaning
5870 this is a bad time to try to read input. */
5872 static int
5873 read_avail_input (expected)
5874 int expected;
5876 struct input_event buf[KBD_BUFFER_SIZE];
5877 register int i;
5878 int nread;
5880 if (read_socket_hook)
5881 /* No need for FIONREAD or fcntl; just say don't wait. */
5882 nread = (*read_socket_hook) (input_fd, buf, KBD_BUFFER_SIZE, expected);
5883 else
5885 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
5886 the kbd_buffer can really hold. That may prevent loss
5887 of characters on some systems when input is stuffed at us. */
5888 unsigned char cbuf[KBD_BUFFER_SIZE - 1];
5889 int n_to_read;
5891 /* Determine how many characters we should *try* to read. */
5892 #ifdef WINDOWSNT
5893 return 0;
5894 #else /* not WINDOWSNT */
5895 #ifdef MSDOS
5896 n_to_read = dos_keysns ();
5897 if (n_to_read == 0)
5898 return 0;
5899 #else /* not MSDOS */
5900 #ifdef FIONREAD
5901 /* Find out how much input is available. */
5902 if (ioctl (input_fd, FIONREAD, &n_to_read) < 0)
5903 /* Formerly simply reported no input, but that sometimes led to
5904 a failure of Emacs to terminate.
5905 SIGHUP seems appropriate if we can't reach the terminal. */
5906 /* ??? Is it really right to send the signal just to this process
5907 rather than to the whole process group?
5908 Perhaps on systems with FIONREAD Emacs is alone in its group. */
5909 kill (getpid (), SIGHUP);
5910 if (n_to_read == 0)
5911 return 0;
5912 if (n_to_read > sizeof cbuf)
5913 n_to_read = sizeof cbuf;
5914 #else /* no FIONREAD */
5915 #if defined (USG) || defined (DGUX)
5916 /* Read some input if available, but don't wait. */
5917 n_to_read = sizeof cbuf;
5918 fcntl (input_fd, F_SETFL, O_NDELAY);
5919 #else
5920 you lose;
5921 #endif
5922 #endif
5923 #endif /* not MSDOS */
5924 #endif /* not WINDOWSNT */
5926 /* Now read; for one reason or another, this will not block.
5927 NREAD is set to the number of chars read. */
5930 #ifdef MSDOS
5931 cbuf[0] = dos_keyread ();
5932 nread = 1;
5933 #else
5934 nread = emacs_read (input_fd, cbuf, n_to_read);
5935 #endif
5936 /* POSIX infers that processes which are not in the session leader's
5937 process group won't get SIGHUP's at logout time. BSDI adheres to
5938 this part standard and returns -1 from read (0) with errno==EIO
5939 when the control tty is taken away.
5940 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
5941 if (nread == -1 && errno == EIO)
5942 kill (0, SIGHUP);
5943 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
5944 /* The kernel sometimes fails to deliver SIGHUP for ptys.
5945 This looks incorrect, but it isn't, because _BSD causes
5946 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
5947 and that causes a value other than 0 when there is no input. */
5948 if (nread == 0)
5949 kill (0, SIGHUP);
5950 #endif
5952 while (
5953 /* We used to retry the read if it was interrupted.
5954 But this does the wrong thing when O_NDELAY causes
5955 an EAGAIN error. Does anybody know of a situation
5956 where a retry is actually needed? */
5957 #if 0
5958 nread < 0 && (errno == EAGAIN
5959 #ifdef EFAULT
5960 || errno == EFAULT
5961 #endif
5962 #ifdef EBADSLT
5963 || errno == EBADSLT
5964 #endif
5966 #else
5968 #endif
5971 #ifndef FIONREAD
5972 #if defined (USG) || defined (DGUX)
5973 fcntl (input_fd, F_SETFL, 0);
5974 #endif /* USG or DGUX */
5975 #endif /* no FIONREAD */
5976 for (i = 0; i < nread; i++)
5978 buf[i].kind = ascii_keystroke;
5979 buf[i].modifiers = 0;
5980 if (meta_key == 1 && (cbuf[i] & 0x80))
5981 buf[i].modifiers = meta_modifier;
5982 if (meta_key != 2)
5983 cbuf[i] &= ~0x80;
5985 buf[i].code = cbuf[i];
5986 buf[i].frame_or_window = selected_frame;
5987 buf[i].arg = Qnil;
5991 /* Scan the chars for C-g and store them in kbd_buffer. */
5992 for (i = 0; i < nread; i++)
5994 kbd_buffer_store_event (&buf[i]);
5995 /* Don't look at input that follows a C-g too closely.
5996 This reduces lossage due to autorepeat on C-g. */
5997 if (buf[i].kind == ascii_keystroke
5998 && buf[i].code == quit_char)
5999 break;
6002 return nread;
6004 #endif /* not VMS */
6006 #ifdef SIGIO /* for entire page */
6007 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6009 SIGTYPE
6010 input_available_signal (signo)
6011 int signo;
6013 /* Must preserve main program's value of errno. */
6014 int old_errno = errno;
6015 #ifdef BSD4_1
6016 extern int select_alarmed;
6017 #endif
6019 #if defined (USG) && !defined (POSIX_SIGNALS)
6020 /* USG systems forget handlers when they are used;
6021 must reestablish each time */
6022 signal (signo, input_available_signal);
6023 #endif /* USG */
6025 #ifdef BSD4_1
6026 sigisheld (SIGIO);
6027 #endif
6029 if (input_available_clear_time)
6030 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
6032 while (1)
6034 int nread;
6035 nread = read_avail_input (1);
6036 /* -1 means it's not ok to read the input now.
6037 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6038 0 means there was no keyboard input available. */
6039 if (nread <= 0)
6040 break;
6042 #ifdef BSD4_1
6043 select_alarmed = 1; /* Force the select emulator back to life */
6044 #endif
6047 #ifdef BSD4_1
6048 sigfree ();
6049 #endif
6050 errno = old_errno;
6052 #endif /* SIGIO */
6054 /* Send ourselves a SIGIO.
6056 This function exists so that the UNBLOCK_INPUT macro in
6057 blockinput.h can have some way to take care of input we put off
6058 dealing with, without assuming that every file which uses
6059 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6060 void
6061 reinvoke_input_signal ()
6063 #ifdef SIGIO
6064 kill (getpid (), SIGIO);
6065 #endif
6070 /* Return the prompt-string of a sparse keymap.
6071 This is the first element which is a string.
6072 Return nil if there is none. */
6074 Lisp_Object
6075 map_prompt (map)
6076 Lisp_Object map;
6078 while (CONSP (map))
6080 register Lisp_Object tem;
6081 tem = Fcar (map);
6082 if (STRINGP (tem))
6083 return tem;
6084 map = Fcdr (map);
6086 return Qnil;
6089 static void menu_bar_item ();
6090 static void menu_bar_one_keymap ();
6092 /* These variables hold the vector under construction within
6093 menu_bar_items and its subroutines, and the current index
6094 for storing into that vector. */
6095 static Lisp_Object menu_bar_items_vector;
6096 static int menu_bar_items_index;
6098 /* Return a vector of menu items for a menu bar, appropriate
6099 to the current buffer. Each item has three elements in the vector:
6100 KEY STRING MAPLIST.
6102 OLD is an old vector we can optionally reuse, or nil. */
6104 Lisp_Object
6105 menu_bar_items (old)
6106 Lisp_Object old;
6108 /* The number of keymaps we're scanning right now, and the number of
6109 keymaps we have allocated space for. */
6110 int nmaps;
6112 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6113 in the current keymaps, or nil where it is not a prefix. */
6114 Lisp_Object *maps;
6116 Lisp_Object def, tem, tail;
6118 Lisp_Object result;
6120 int mapno;
6121 Lisp_Object oquit;
6123 int i;
6125 struct gcpro gcpro1;
6127 /* In order to build the menus, we need to call the keymap
6128 accessors. They all call QUIT. But this function is called
6129 during redisplay, during which a quit is fatal. So inhibit
6130 quitting while building the menus.
6131 We do this instead of specbind because (1) errors will clear it anyway
6132 and (2) this avoids risk of specpdl overflow. */
6133 oquit = Vinhibit_quit;
6134 Vinhibit_quit = Qt;
6136 if (!NILP (old))
6137 menu_bar_items_vector = old;
6138 else
6139 menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
6140 menu_bar_items_index = 0;
6142 GCPRO1 (menu_bar_items_vector);
6144 /* Build our list of keymaps.
6145 If we recognize a function key and replace its escape sequence in
6146 keybuf with its symbol, or if the sequence starts with a mouse
6147 click and we need to switch buffers, we jump back here to rebuild
6148 the initial keymaps from the current buffer. */
6150 Lisp_Object *tmaps;
6152 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6153 if (!NILP (Voverriding_local_map_menu_flag))
6155 /* Yes, use them (if non-nil) as well as the global map. */
6156 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
6157 nmaps = 0;
6158 if (!NILP (current_kboard->Voverriding_terminal_local_map))
6159 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
6160 if (!NILP (Voverriding_local_map))
6161 maps[nmaps++] = Voverriding_local_map;
6163 else
6165 /* No, so use major and minor mode keymaps and keymap property. */
6166 int extra_maps = 2;
6167 Lisp_Object map = get_local_map (PT, current_buffer, keymap);
6168 if (!NILP (map))
6169 extra_maps = 3;
6170 nmaps = current_minor_maps (NULL, &tmaps);
6171 maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
6172 * sizeof (maps[0]));
6173 bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
6174 if (!NILP (map))
6175 maps[nmaps++] = get_local_map (PT, current_buffer, keymap);
6176 maps[nmaps++] = get_local_map (PT, current_buffer, local_map);
6178 maps[nmaps++] = current_global_map;
6181 /* Look up in each map the dummy prefix key `menu-bar'. */
6183 result = Qnil;
6185 for (mapno = nmaps - 1; mapno >= 0; mapno--)
6187 if (! NILP (maps[mapno]))
6188 def = get_keyelt (access_keymap (maps[mapno], Qmenu_bar, 1, 0), 0);
6189 else
6190 def = Qnil;
6192 tem = Fkeymapp (def);
6193 if (!NILP (tem))
6194 menu_bar_one_keymap (def);
6197 /* Move to the end those items that should be at the end. */
6199 for (tail = Vmenu_bar_final_items; CONSP (tail); tail = XCDR (tail))
6201 int i;
6202 int end = menu_bar_items_index;
6204 for (i = 0; i < end; i += 4)
6205 if (EQ (XCAR (tail), XVECTOR (menu_bar_items_vector)->contents[i]))
6207 Lisp_Object tem0, tem1, tem2, tem3;
6208 /* Move the item at index I to the end,
6209 shifting all the others forward. */
6210 tem0 = XVECTOR (menu_bar_items_vector)->contents[i + 0];
6211 tem1 = XVECTOR (menu_bar_items_vector)->contents[i + 1];
6212 tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
6213 tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
6214 if (end > i + 4)
6215 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
6216 &XVECTOR (menu_bar_items_vector)->contents[i],
6217 (end - i - 4) * sizeof (Lisp_Object));
6218 XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
6219 XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
6220 XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
6221 XVECTOR (menu_bar_items_vector)->contents[end - 1] = tem3;
6222 break;
6226 /* Add nil, nil, nil, nil at the end. */
6227 i = menu_bar_items_index;
6228 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
6230 Lisp_Object tem;
6231 tem = Fmake_vector (make_number (2 * i), Qnil);
6232 bcopy (XVECTOR (menu_bar_items_vector)->contents,
6233 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
6234 menu_bar_items_vector = tem;
6236 /* Add this item. */
6237 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6238 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6239 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6240 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6241 menu_bar_items_index = i;
6243 Vinhibit_quit = oquit;
6244 UNGCPRO;
6245 return menu_bar_items_vector;
6248 /* Scan one map KEYMAP, accumulating any menu items it defines
6249 in menu_bar_items_vector. */
6251 static Lisp_Object menu_bar_one_keymap_changed_items;
6253 static void
6254 menu_bar_one_keymap (keymap)
6255 Lisp_Object keymap;
6257 Lisp_Object tail, item;
6259 menu_bar_one_keymap_changed_items = Qnil;
6261 /* Loop over all keymap entries that have menu strings. */
6262 for (tail = keymap; CONSP (tail); tail = XCDR (tail))
6264 item = XCAR (tail);
6265 if (CONSP (item))
6266 menu_bar_item (XCAR (item), XCDR (item));
6267 else if (VECTORP (item))
6269 /* Loop over the char values represented in the vector. */
6270 int len = XVECTOR (item)->size;
6271 int c;
6272 for (c = 0; c < len; c++)
6274 Lisp_Object character;
6275 XSETFASTINT (character, c);
6276 menu_bar_item (character, XVECTOR (item)->contents[c]);
6282 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
6283 If there's already an item for KEY, add this DEF to it. */
6285 Lisp_Object item_properties;
6287 static void
6288 menu_bar_item (key, item)
6289 Lisp_Object key, item;
6291 struct gcpro gcpro1;
6292 int i;
6293 Lisp_Object tem;
6295 if (EQ (item, Qundefined))
6297 /* If a map has an explicit `undefined' as definition,
6298 discard any previously made menu bar item. */
6300 for (i = 0; i < menu_bar_items_index; i += 4)
6301 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
6303 if (menu_bar_items_index > i + 4)
6304 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
6305 &XVECTOR (menu_bar_items_vector)->contents[i],
6306 (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
6307 menu_bar_items_index -= 4;
6308 return;
6311 /* If there's no definition for this key yet,
6312 just ignore `undefined'. */
6313 return;
6316 GCPRO1 (key); /* Is this necessary? */
6317 i = parse_menu_item (item, 0, 1);
6318 UNGCPRO;
6319 if (!i)
6320 return;
6322 /* If this keymap has already contributed to this KEY,
6323 don't contribute to it a second time. */
6324 tem = Fmemq (key, menu_bar_one_keymap_changed_items);
6325 if (!NILP (tem))
6326 return;
6328 menu_bar_one_keymap_changed_items
6329 = Fcons (key, menu_bar_one_keymap_changed_items);
6331 item = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
6333 /* Find any existing item for this KEY. */
6334 for (i = 0; i < menu_bar_items_index; i += 4)
6335 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
6336 break;
6338 /* If we did not find this KEY, add it at the end. */
6339 if (i == menu_bar_items_index)
6341 /* If vector is too small, get a bigger one. */
6342 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
6344 Lisp_Object tem;
6345 tem = Fmake_vector (make_number (2 * i), Qnil);
6346 bcopy (XVECTOR (menu_bar_items_vector)->contents,
6347 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
6348 menu_bar_items_vector = tem;
6351 /* Add this item. */
6352 XVECTOR (menu_bar_items_vector)->contents[i++] = key;
6353 XVECTOR (menu_bar_items_vector)->contents[i++]
6354 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
6355 XVECTOR (menu_bar_items_vector)->contents[i++] = Fcons (item, Qnil);
6356 XVECTOR (menu_bar_items_vector)->contents[i++] = make_number (0);
6357 menu_bar_items_index = i;
6359 /* We did find an item for this KEY. Add ITEM to its list of maps. */
6360 else
6362 Lisp_Object old;
6363 old = XVECTOR (menu_bar_items_vector)->contents[i + 2];
6364 XVECTOR (menu_bar_items_vector)->contents[i + 2] = Fcons (item, old);
6368 /* This is used as the handler when calling menu_item_eval_property. */
6369 static Lisp_Object
6370 menu_item_eval_property_1 (arg)
6371 Lisp_Object arg;
6373 /* If we got a quit from within the menu computation,
6374 quit all the way out of it. This takes care of C-] in the debugger. */
6375 if (CONSP (arg) && EQ (XCAR (arg), Qquit))
6376 Fsignal (Qquit, Qnil);
6378 return Qnil;
6381 /* Evaluate an expression and return the result (or nil if something
6382 went wrong). Used to evaluate dynamic parts of menu items. */
6383 Lisp_Object
6384 menu_item_eval_property (sexpr)
6385 Lisp_Object sexpr;
6387 int count = specpdl_ptr - specpdl;
6388 Lisp_Object val;
6389 specbind (Qinhibit_redisplay, Qt);
6390 val = internal_condition_case_1 (Feval, sexpr, Qerror,
6391 menu_item_eval_property_1);
6392 return unbind_to (count, val);
6395 /* This function parses a menu item and leaves the result in the
6396 vector item_properties.
6397 ITEM is a key binding, a possible menu item.
6398 If NOTREAL is nonzero, only check for equivalent key bindings, don't
6399 evaluate dynamic expressions in the menu item.
6400 INMENUBAR is > 0 when this is considered for an entry in a menu bar
6401 top level.
6402 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
6403 parse_menu_item returns true if the item is a menu item and false
6404 otherwise. */
6407 parse_menu_item (item, notreal, inmenubar)
6408 Lisp_Object item;
6409 int notreal, inmenubar;
6411 Lisp_Object def, tem, item_string, start;
6412 Lisp_Object cachelist;
6413 Lisp_Object filter;
6414 Lisp_Object keyhint;
6415 int i;
6416 int newcache = 0;
6418 cachelist = Qnil;
6419 filter = Qnil;
6420 keyhint = Qnil;
6422 if (!CONSP (item))
6423 return 0;
6425 /* Create item_properties vector if necessary. */
6426 if (NILP (item_properties))
6427 item_properties
6428 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE + 1), Qnil);
6430 /* Initialize optional entries. */
6431 for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
6432 XVECTOR (item_properties)->contents[i] = Qnil;
6433 XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = Qt;
6435 /* Save the item here to protect it from GC. */
6436 XVECTOR (item_properties)->contents[ITEM_PROPERTY_ITEM] = item;
6438 item_string = XCAR (item);
6440 start = item;
6441 item = XCDR (item);
6442 if (STRINGP (item_string))
6444 /* Old format menu item. */
6445 XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME] = item_string;
6447 /* Maybe help string. */
6448 if (CONSP (item) && STRINGP (XCAR (item)))
6450 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]
6451 = XCAR (item);
6452 start = item;
6453 item = XCDR (item);
6456 /* Maybe key binding cache. */
6457 if (CONSP (item) && CONSP (XCAR (item))
6458 && (NILP (XCAR (XCAR (item)))
6459 || VECTORP (XCAR (XCAR (item)))))
6461 cachelist = XCAR (item);
6462 item = XCDR (item);
6465 /* This is the real definition--the function to run. */
6466 XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = item;
6468 /* Get enable property, if any. */
6469 if (SYMBOLP (item))
6471 tem = Fget (item, Qmenu_enable);
6472 if (!NILP (tem))
6473 XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = tem;
6476 else if (EQ (item_string, Qmenu_item) && CONSP (item))
6478 /* New format menu item. */
6479 XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME]
6480 = XCAR (item);
6481 start = XCDR (item);
6482 if (CONSP (start))
6484 /* We have a real binding. */
6485 XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF]
6486 = XCAR (start);
6488 item = XCDR (start);
6489 /* Is there a cache list with key equivalences. */
6490 if (CONSP (item) && CONSP (XCAR (item)))
6492 cachelist = XCAR (item);
6493 item = XCDR (item);
6496 /* Parse properties. */
6497 while (CONSP (item) && CONSP (XCDR (item)))
6499 tem = XCAR (item);
6500 item = XCDR (item);
6502 if (EQ (tem, QCenable))
6503 XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE]
6504 = XCAR (item);
6505 else if (EQ (tem, QCvisible) && !notreal)
6507 /* If got a visible property and that evaluates to nil
6508 then ignore this item. */
6509 tem = menu_item_eval_property (XCAR (item));
6510 if (NILP (tem))
6511 return 0;
6513 else if (EQ (tem, QChelp))
6514 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP]
6515 = XCAR (item);
6516 else if (EQ (tem, QCfilter))
6517 filter = item;
6518 else if (EQ (tem, QCkey_sequence))
6520 tem = XCAR (item);
6521 if (NILP (cachelist)
6522 && (SYMBOLP (tem) || STRINGP (tem) || VECTORP (tem)))
6523 /* Be GC protected. Set keyhint to item instead of tem. */
6524 keyhint = item;
6526 else if (EQ (tem, QCkeys))
6528 tem = XCAR (item);
6529 if (CONSP (tem) || (STRINGP (tem) && NILP (cachelist)))
6530 XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ]
6531 = tem;
6533 else if (EQ (tem, QCbutton) && CONSP (XCAR (item)))
6535 Lisp_Object type;
6536 tem = XCAR (item);
6537 type = XCAR (tem);
6538 if (EQ (type, QCtoggle) || EQ (type, QCradio))
6540 XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED]
6541 = XCDR (tem);
6542 XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE]
6543 = type;
6546 item = XCDR (item);
6549 else if (inmenubar || !NILP (start))
6550 return 0;
6552 else
6553 return 0; /* not a menu item */
6555 /* If item string is not a string, evaluate it to get string.
6556 If we don't get a string, skip this item. */
6557 item_string = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
6558 if (!(STRINGP (item_string) || notreal))
6560 item_string = menu_item_eval_property (item_string);
6561 if (!STRINGP (item_string))
6562 return 0;
6563 XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME] = item_string;
6566 /* If got a filter apply it on definition. */
6567 def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
6568 if (!NILP (filter))
6570 def = menu_item_eval_property (list2 (XCAR (filter),
6571 list2 (Qquote, def)));
6573 XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = def;
6576 /* If we got no definition, this item is just unselectable text which
6577 is OK in a submenu but not in the menubar. */
6578 if (NILP (def))
6579 return (inmenubar ? 0 : 1);
6581 /* Enable or disable selection of item. */
6582 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE];
6583 if (!EQ (tem, Qt))
6585 if (notreal)
6586 tem = Qt;
6587 else
6588 tem = menu_item_eval_property (tem);
6589 if (inmenubar && NILP (tem))
6590 return 0; /* Ignore disabled items in menu bar. */
6591 XVECTOR (item_properties)->contents[ITEM_PROPERTY_ENABLE] = tem;
6594 /* See if this is a separate pane or a submenu. */
6595 def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
6596 tem = get_keymap_1 (def, 0, 1);
6597 /* For a subkeymap, just record its details and exit. */
6598 if (!NILP (tem))
6600 XVECTOR (item_properties)->contents[ITEM_PROPERTY_MAP] = tem;
6601 XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF] = tem;
6602 return 1;
6604 /* At the top level in the menu bar, do likewise for commands also.
6605 The menu bar does not display equivalent key bindings anyway.
6606 ITEM_PROPERTY_DEF is already set up properly. */
6607 if (inmenubar > 0)
6608 return 1;
6610 /* This is a command. See if there is an equivalent key binding. */
6611 if (NILP (cachelist))
6613 /* We have to create a cachelist. */
6614 CHECK_IMPURE (start);
6615 XCDR (start) = Fcons (Fcons (Qnil, Qnil), XCDR (start));
6616 cachelist = XCAR (XCDR (start));
6617 newcache = 1;
6618 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
6619 if (!NILP (keyhint))
6621 XCAR (cachelist) = XCAR (keyhint);
6622 newcache = 0;
6624 else if (STRINGP (tem))
6626 XCDR (cachelist) = Fsubstitute_command_keys (tem);
6627 XCAR (cachelist) = Qt;
6630 tem = XCAR (cachelist);
6631 if (!EQ (tem, Qt))
6633 int chkcache = 0;
6634 Lisp_Object prefix;
6636 if (!NILP (tem))
6637 tem = Fkey_binding (tem, Qnil);
6639 prefix = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
6640 if (CONSP (prefix))
6642 def = XCAR (prefix);
6643 prefix = XCDR (prefix);
6645 else
6646 def = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
6648 if (NILP (XCAR (cachelist))) /* Have no saved key. */
6650 if (newcache /* Always check first time. */
6651 /* Should we check everything when precomputing key
6652 bindings? */
6653 /* || notreal */
6654 /* If something had no key binding before, don't recheck it
6655 because that is too slow--except if we have a list of
6656 rebound commands in Vdefine_key_rebound_commands, do
6657 recheck any command that appears in that list. */
6658 || (CONSP (Vdefine_key_rebound_commands)
6659 && !NILP (Fmemq (def, Vdefine_key_rebound_commands))))
6660 chkcache = 1;
6662 /* We had a saved key. Is it still bound to the command? */
6663 else if (NILP (tem)
6664 || (!EQ (tem, def)
6665 /* If the command is an alias for another
6666 (such as lmenu.el set it up), check if the
6667 original command matches the cached command. */
6668 && !(SYMBOLP (def) && EQ (tem, XSYMBOL (def)->function))))
6669 chkcache = 1; /* Need to recompute key binding. */
6671 if (chkcache)
6673 /* Recompute equivalent key binding. If the command is an alias
6674 for another (such as lmenu.el set it up), see if the original
6675 command name has equivalent keys. Otherwise look up the
6676 specified command itself. We don't try both, because that
6677 makes lmenu menus slow. */
6678 if (SYMBOLP (def) && SYMBOLP (XSYMBOL (def)->function)
6679 && ! NILP (Fget (def, Qmenu_alias)))
6680 def = XSYMBOL (def)->function;
6681 tem = Fwhere_is_internal (def, Qnil, Qt, Qnil);
6682 XCAR (cachelist) = tem;
6683 if (NILP (tem))
6685 XCDR (cachelist) = Qnil;
6686 chkcache = 0;
6689 else if (!NILP (keyhint) && !NILP (XCAR (cachelist)))
6691 tem = XCAR (cachelist);
6692 chkcache = 1;
6695 newcache = chkcache;
6696 if (chkcache)
6698 tem = Fkey_description (tem);
6699 if (CONSP (prefix))
6701 if (STRINGP (XCAR (prefix)))
6702 tem = concat2 (XCAR (prefix), tem);
6703 if (STRINGP (XCDR (prefix)))
6704 tem = concat2 (tem, XCDR (prefix));
6706 XCDR (cachelist) = tem;
6710 tem = XCDR (cachelist);
6711 if (newcache && !NILP (tem))
6713 tem = concat3 (build_string (" ("), tem, build_string (")"));
6714 XCDR (cachelist) = tem;
6717 /* If we only want to precompute equivalent key bindings, stop here. */
6718 if (notreal)
6719 return 1;
6721 /* If we have an equivalent key binding, use that. */
6722 XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ] = tem;
6724 /* Include this when menu help is implemented.
6725 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
6726 if (!(NILP (tem) || STRINGP (tem)))
6728 tem = menu_item_eval_property (tem);
6729 if (!STRINGP (tem))
6730 tem = Qnil;
6731 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
6735 /* Handle radio buttons or toggle boxes. */
6736 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
6737 if (!NILP (tem))
6738 XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED]
6739 = menu_item_eval_property (tem);
6741 return 1;
6746 /***********************************************************************
6747 Tool-bars
6748 ***********************************************************************/
6750 /* A vector holding tool bar items while they are parsed in function
6751 tool_bar_items runs Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
6752 in the vector. */
6754 static Lisp_Object tool_bar_items_vector;
6756 /* A vector holding the result of parse_tool_bar_item. Layout is like
6757 the one for a single item in tool_bar_items_vector. */
6759 static Lisp_Object tool_bar_item_properties;
6761 /* Next free index in tool_bar_items_vector. */
6763 static int ntool_bar_items;
6765 /* The symbols `tool-bar', and `:image'. */
6767 extern Lisp_Object Qtool_bar;
6768 Lisp_Object QCimage;
6770 /* Function prototypes. */
6772 static void init_tool_bar_items P_ ((Lisp_Object));
6773 static void process_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
6774 static int parse_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
6775 static void append_tool_bar_item P_ ((void));
6778 /* Return a vector of tool bar items for keymaps currently in effect.
6779 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
6780 tool bar items found. */
6782 Lisp_Object
6783 tool_bar_items (reuse, nitems)
6784 Lisp_Object reuse;
6785 int *nitems;
6787 Lisp_Object *maps;
6788 int nmaps, i;
6789 Lisp_Object oquit;
6790 Lisp_Object *tmaps;
6791 extern Lisp_Object Voverriding_local_map_menu_flag;
6792 extern Lisp_Object Voverriding_local_map;
6794 *nitems = 0;
6796 /* In order to build the menus, we need to call the keymap
6797 accessors. They all call QUIT. But this function is called
6798 during redisplay, during which a quit is fatal. So inhibit
6799 quitting while building the menus. We do this instead of
6800 specbind because (1) errors will clear it anyway and (2) this
6801 avoids risk of specpdl overflow. */
6802 oquit = Vinhibit_quit;
6803 Vinhibit_quit = Qt;
6805 /* Initialize tool_bar_items_vector and protect it from GC. */
6806 init_tool_bar_items (reuse);
6808 /* Build list of keymaps in maps. Set nmaps to the number of maps
6809 to process. */
6811 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6812 if (!NILP (Voverriding_local_map_menu_flag))
6814 /* Yes, use them (if non-nil) as well as the global map. */
6815 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
6816 nmaps = 0;
6817 if (!NILP (current_kboard->Voverriding_terminal_local_map))
6818 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
6819 if (!NILP (Voverriding_local_map))
6820 maps[nmaps++] = Voverriding_local_map;
6822 else
6824 /* No, so use major and minor mode keymaps and keymap property. */
6825 int extra_maps = 2;
6826 Lisp_Object map = get_local_map (PT, current_buffer, keymap);
6827 if (!NILP (map))
6828 extra_maps = 3;
6829 nmaps = current_minor_maps (NULL, &tmaps);
6830 maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
6831 * sizeof (maps[0]));
6832 bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
6833 if (!NILP (map))
6834 maps[nmaps++] = get_local_map (PT, current_buffer, keymap);
6835 maps[nmaps++] = get_local_map (PT, current_buffer, local_map);
6838 /* Add global keymap at the end. */
6839 maps[nmaps++] = current_global_map;
6841 /* Process maps in reverse order and look up in each map the prefix
6842 key `tool-bar'. */
6843 for (i = nmaps - 1; i >= 0; --i)
6844 if (!NILP (maps[i]))
6846 Lisp_Object keymap;
6848 keymap = get_keyelt (access_keymap (maps[i], Qtool_bar, 1, 1), 0);
6849 if (!NILP (Fkeymapp (keymap)))
6851 Lisp_Object tail;
6853 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
6854 for (tail = keymap; CONSP (tail); tail = XCDR (tail))
6856 Lisp_Object keydef = XCAR (tail);
6857 if (CONSP (keydef))
6858 process_tool_bar_item (XCAR (keydef), XCDR (keydef));
6863 Vinhibit_quit = oquit;
6864 *nitems = ntool_bar_items / TOOL_BAR_ITEM_NSLOTS;
6865 return tool_bar_items_vector;
6869 /* Process the definition of KEY which is DEF. */
6871 static void
6872 process_tool_bar_item (key, def)
6873 Lisp_Object key, def;
6875 int i;
6876 extern Lisp_Object Qundefined;
6877 struct gcpro gcpro1, gcpro2;
6879 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
6880 eval. */
6881 GCPRO2 (key, def);
6883 if (EQ (def, Qundefined))
6885 /* If a map has an explicit `undefined' as definition,
6886 discard any previously made item. */
6887 for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
6889 Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
6891 if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
6893 if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
6894 bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
6895 ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
6896 * sizeof (Lisp_Object)));
6897 ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
6898 break;
6902 else if (parse_tool_bar_item (key, def))
6903 /* Append a new tool bar item to tool_bar_items_vector. Accept
6904 more than one definition for the same key. */
6905 append_tool_bar_item ();
6907 UNGCPRO;
6911 /* Parse a tool bar item specification ITEM for key KEY and return the
6912 result in tool_bar_item_properties. Value is zero if ITEM is
6913 invalid.
6915 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
6917 CAPTION is the caption of the item, If it's not a string, it is
6918 evaluated to get a string.
6920 BINDING is the tool bar item's binding. Tool-bar items with keymaps
6921 as binding are currently ignored.
6923 The following properties are recognized:
6925 - `:enable FORM'.
6927 FORM is evaluated and specifies whether the tool bar item is
6928 enabled or disabled.
6930 - `:visible FORM'
6932 FORM is evaluated and specifies whether the tool bar item is visible.
6934 - `:filter FUNCTION'
6936 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
6937 result is stored as the new binding.
6939 - `:button (TYPE SELECTED)'
6941 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
6942 and specifies whether the button is selected (pressed) or not.
6944 - `:image IMAGES'
6946 IMAGES is either a single image specification or a vector of four
6947 image specifications. See enum tool_bar_item_images.
6949 - `:help HELP-STRING'.
6951 Gives a help string to display for the tool bar item. */
6953 static int
6954 parse_tool_bar_item (key, item)
6955 Lisp_Object key, item;
6957 /* Access slot with index IDX of vector tool_bar_item_properties. */
6958 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
6960 Lisp_Object filter = Qnil;
6961 Lisp_Object caption;
6962 extern Lisp_Object QCenable, QCvisible, QChelp, QCfilter;
6963 extern Lisp_Object QCbutton, QCtoggle, QCradio;
6964 int i;
6966 /* Defininition looks like `(tool-bar-item CAPTION BINDING
6967 PROPS...)'. Rule out items that aren't lists, don't start with
6968 `tool-bar-item' or whose rest following `tool-bar-item' is not a
6969 list. */
6970 if (!CONSP (item)
6971 || !EQ (XCAR (item), Qmenu_item)
6972 || (item = XCDR (item),
6973 !CONSP (item)))
6974 return 0;
6976 /* Create tool_bar_item_properties vector if necessary. Reset it to
6977 defaults. */
6978 if (VECTORP (tool_bar_item_properties))
6980 for (i = 0; i < TOOL_BAR_ITEM_NSLOTS; ++i)
6981 PROP (i) = Qnil;
6983 else
6984 tool_bar_item_properties
6985 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS), Qnil);
6987 /* Set defaults. */
6988 PROP (TOOL_BAR_ITEM_KEY) = key;
6989 PROP (TOOL_BAR_ITEM_ENABLED_P) = Qt;
6991 /* Get the caption of the item. If the caption is not a string,
6992 evaluate it to get a string. If we don't get a string, skip this
6993 item. */
6994 caption = XCAR (item);
6995 if (!STRINGP (caption))
6997 caption = menu_item_eval_property (caption);
6998 if (!STRINGP (caption))
6999 return 0;
7001 PROP (TOOL_BAR_ITEM_CAPTION) = caption;
7003 /* Give up if rest following the caption is not a list. */
7004 item = XCDR (item);
7005 if (!CONSP (item))
7006 return 0;
7008 /* Store the binding. */
7009 PROP (TOOL_BAR_ITEM_BINDING) = XCAR (item);
7010 item = XCDR (item);
7012 /* Process the rest of the properties. */
7013 for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
7015 Lisp_Object key, value;
7017 key = XCAR (item);
7018 value = XCAR (XCDR (item));
7020 if (EQ (key, QCenable))
7021 /* `:enable FORM'. */
7022 PROP (TOOL_BAR_ITEM_ENABLED_P) = value;
7023 else if (EQ (key, QCvisible))
7025 /* `:visible FORM'. If got a visible property and that
7026 evaluates to nil then ignore this item. */
7027 if (NILP (menu_item_eval_property (value)))
7028 return 0;
7030 else if (EQ (key, QChelp))
7031 /* `:help HELP-STRING'. */
7032 PROP (TOOL_BAR_ITEM_HELP) = value;
7033 else if (EQ (key, QCfilter))
7034 /* ':filter FORM'. */
7035 filter = value;
7036 else if (EQ (key, QCbutton) && CONSP (value))
7038 /* `:button (TYPE . SELECTED)'. */
7039 Lisp_Object type, selected;
7041 type = XCAR (value);
7042 selected = XCDR (value);
7043 if (EQ (type, QCtoggle) || EQ (type, QCradio))
7045 PROP (TOOL_BAR_ITEM_SELECTED_P) = selected;
7046 PROP (TOOL_BAR_ITEM_TYPE) = type;
7049 else if (EQ (key, QCimage)
7050 && (CONSP (value)
7051 || (VECTORP (value) && XVECTOR (value)->size == 4)))
7052 /* Value is either a single image specification or a vector
7053 of 4 such specifications for the different buttion states. */
7054 PROP (TOOL_BAR_ITEM_IMAGES) = value;
7057 /* If got a filter apply it on binding. */
7058 if (!NILP (filter))
7059 PROP (TOOL_BAR_ITEM_BINDING)
7060 = menu_item_eval_property (list2 (filter,
7061 list2 (Qquote,
7062 PROP (TOOL_BAR_ITEM_BINDING))));
7064 /* See if the binding is a keymap. Give up if it is. */
7065 if (!NILP (get_keymap_1 (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
7066 return 0;
7068 /* Enable or disable selection of item. */
7069 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P), Qt))
7070 PROP (TOOL_BAR_ITEM_ENABLED_P)
7071 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P));
7073 /* Handle radio buttons or toggle boxes. */
7074 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P)))
7075 PROP (TOOL_BAR_ITEM_SELECTED_P)
7076 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P));
7078 return 1;
7080 #undef PROP
7084 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7085 that can be reused. */
7087 static void
7088 init_tool_bar_items (reuse)
7089 Lisp_Object reuse;
7091 if (VECTORP (reuse))
7092 tool_bar_items_vector = reuse;
7093 else
7094 tool_bar_items_vector = Fmake_vector (make_number (64), Qnil);
7095 ntool_bar_items = 0;
7099 /* Append parsed tool bar item properties from
7100 tool_bar_item_properties */
7102 static void
7103 append_tool_bar_item ()
7105 Lisp_Object *to, *from;
7107 /* Enlarge tool_bar_items_vector if necessary. */
7108 if (ntool_bar_items + TOOL_BAR_ITEM_NSLOTS
7109 >= XVECTOR (tool_bar_items_vector)->size)
7111 Lisp_Object new_vector;
7112 int old_size = XVECTOR (tool_bar_items_vector)->size;
7114 new_vector = Fmake_vector (make_number (2 * old_size), Qnil);
7115 bcopy (XVECTOR (tool_bar_items_vector)->contents,
7116 XVECTOR (new_vector)->contents,
7117 old_size * sizeof (Lisp_Object));
7118 tool_bar_items_vector = new_vector;
7121 /* Append entries from tool_bar_item_properties to the end of
7122 tool_bar_items_vector. */
7123 to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
7124 from = XVECTOR (tool_bar_item_properties)->contents;
7125 bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
7126 ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
7133 /* Read a character using menus based on maps in the array MAPS.
7134 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7135 Return t if we displayed a menu but the user rejected it.
7137 PREV_EVENT is the previous input event, or nil if we are reading
7138 the first event of a key sequence.
7140 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7141 if we used a mouse menu to read the input, or zero otherwise. If
7142 USED_MOUSE_MENU is null, we don't dereference it.
7144 The prompting is done based on the prompt-string of the map
7145 and the strings associated with various map elements.
7147 This can be done with X menus or with menus put in the minibuf.
7148 These are done in different ways, depending on how the input will be read.
7149 Menus using X are done after auto-saving in read-char, getting the input
7150 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7151 and do auto-saving in the inner call of read_char. */
7153 static Lisp_Object
7154 read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
7155 int nmaps;
7156 Lisp_Object *maps;
7157 Lisp_Object prev_event;
7158 int *used_mouse_menu;
7160 int mapno;
7161 register Lisp_Object name;
7163 if (used_mouse_menu)
7164 *used_mouse_menu = 0;
7166 /* Use local over global Menu maps */
7168 if (! menu_prompting)
7169 return Qnil;
7171 /* Optionally disregard all but the global map. */
7172 if (inhibit_local_menu_bar_menus)
7174 maps += (nmaps - 1);
7175 nmaps = 1;
7178 /* Get the menu name from the first map that has one (a prompt string). */
7179 for (mapno = 0; mapno < nmaps; mapno++)
7181 name = map_prompt (maps[mapno]);
7182 if (!NILP (name))
7183 break;
7186 /* If we don't have any menus, just read a character normally. */
7187 if (mapno >= nmaps)
7188 return Qnil;
7190 #ifdef HAVE_MENUS
7191 /* If we got to this point via a mouse click,
7192 use a real menu for mouse selection. */
7193 if (EVENT_HAS_PARAMETERS (prev_event)
7194 && !EQ (XCAR (prev_event), Qmenu_bar)
7195 && !EQ (XCAR (prev_event), Qtool_bar))
7197 /* Display the menu and get the selection. */
7198 Lisp_Object *realmaps
7199 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
7200 Lisp_Object value;
7201 int nmaps1 = 0;
7203 /* Use the maps that are not nil. */
7204 for (mapno = 0; mapno < nmaps; mapno++)
7205 if (!NILP (maps[mapno]))
7206 realmaps[nmaps1++] = maps[mapno];
7208 value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
7209 if (CONSP (value))
7211 Lisp_Object tem;
7213 record_menu_key (XCAR (value));
7215 /* If we got multiple events, unread all but
7216 the first.
7217 There is no way to prevent those unread events
7218 from showing up later in last_nonmenu_event.
7219 So turn symbol and integer events into lists,
7220 to indicate that they came from a mouse menu,
7221 so that when present in last_nonmenu_event
7222 they won't confuse things. */
7223 for (tem = XCDR (value); !NILP (tem);
7224 tem = XCDR (tem))
7226 record_menu_key (XCAR (tem));
7227 if (SYMBOLP (XCAR (tem))
7228 || INTEGERP (XCAR (tem)))
7229 XCAR (tem)
7230 = Fcons (XCAR (tem), Qnil);
7233 /* If we got more than one event, put all but the first
7234 onto this list to be read later.
7235 Return just the first event now. */
7236 Vunread_command_events
7237 = nconc2 (XCDR (value), Vunread_command_events);
7238 value = XCAR (value);
7240 else if (NILP (value))
7241 value = Qt;
7242 if (used_mouse_menu)
7243 *used_mouse_menu = 1;
7244 return value;
7246 #endif /* HAVE_MENUS */
7247 return Qnil ;
7250 /* Buffer in use so far for the minibuf prompts for menu keymaps.
7251 We make this bigger when necessary, and never free it. */
7252 static char *read_char_minibuf_menu_text;
7253 /* Size of that buffer. */
7254 static int read_char_minibuf_menu_width;
7256 static Lisp_Object
7257 read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
7258 int commandflag ;
7259 int nmaps;
7260 Lisp_Object *maps;
7262 int mapno;
7263 register Lisp_Object name;
7264 int nlength;
7265 int width = FRAME_WIDTH (SELECTED_FRAME ()) - 4;
7266 int idx = -1;
7267 int nobindings = 1;
7268 Lisp_Object rest, vector;
7269 char *menu;
7271 if (! menu_prompting)
7272 return Qnil;
7274 /* Make sure we have a big enough buffer for the menu text. */
7275 if (read_char_minibuf_menu_text == 0)
7277 read_char_minibuf_menu_width = width + 4;
7278 read_char_minibuf_menu_text = (char *) xmalloc (width + 4);
7280 else if (width + 4 > read_char_minibuf_menu_width)
7282 read_char_minibuf_menu_width = width + 4;
7283 read_char_minibuf_menu_text
7284 = (char *) xrealloc (read_char_minibuf_menu_text, width + 4);
7286 menu = read_char_minibuf_menu_text;
7288 /* Get the menu name from the first map that has one (a prompt string). */
7289 for (mapno = 0; mapno < nmaps; mapno++)
7291 name = map_prompt (maps[mapno]);
7292 if (!NILP (name))
7293 break;
7296 /* If we don't have any menus, just read a character normally. */
7297 if (mapno >= nmaps)
7298 return Qnil;
7300 /* Prompt string always starts with map's prompt, and a space. */
7301 strcpy (menu, XSTRING (name)->data);
7302 nlength = STRING_BYTES (XSTRING (name));
7303 menu[nlength++] = ':';
7304 menu[nlength++] = ' ';
7305 menu[nlength] = 0;
7307 /* Start prompting at start of first map. */
7308 mapno = 0;
7309 rest = maps[mapno];
7311 /* Present the documented bindings, a line at a time. */
7312 while (1)
7314 int notfirst = 0;
7315 int i = nlength;
7316 Lisp_Object obj;
7317 int ch;
7318 Lisp_Object orig_defn_macro;
7320 /* Loop over elements of map. */
7321 while (i < width)
7323 Lisp_Object elt;
7325 /* If reached end of map, start at beginning of next map. */
7326 if (NILP (rest))
7328 mapno++;
7329 /* At end of last map, wrap around to first map if just starting,
7330 or end this line if already have something on it. */
7331 if (mapno == nmaps)
7333 mapno = 0;
7334 if (notfirst || nobindings) break;
7336 rest = maps[mapno];
7339 /* Look at the next element of the map. */
7340 if (idx >= 0)
7341 elt = XVECTOR (vector)->contents[idx];
7342 else
7343 elt = Fcar_safe (rest);
7345 if (idx < 0 && VECTORP (elt))
7347 /* If we found a dense table in the keymap,
7348 advanced past it, but start scanning its contents. */
7349 rest = Fcdr_safe (rest);
7350 vector = elt;
7351 idx = 0;
7353 else
7355 /* An ordinary element. */
7356 Lisp_Object event, tem;
7358 if (idx < 0)
7360 event = Fcar_safe (elt); /* alist */
7361 elt = Fcdr_safe (elt);
7363 else
7365 XSETINT (event, idx); /* vector */
7368 /* Ignore the element if it has no prompt string. */
7369 if (INTEGERP (event) && parse_menu_item (elt, 0, -1))
7371 /* 1 if the char to type matches the string. */
7372 int char_matches;
7373 Lisp_Object upcased_event, downcased_event;
7374 Lisp_Object desc;
7375 Lisp_Object s
7376 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
7378 upcased_event = Fupcase (event);
7379 downcased_event = Fdowncase (event);
7380 char_matches = (XINT (upcased_event) == XSTRING (s)->data[0]
7381 || XINT (downcased_event) == XSTRING (s)->data[0]);
7382 if (! char_matches)
7383 desc = Fsingle_key_description (event, Qnil);
7386 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
7387 if (!NILP (tem))
7388 /* Insert equivalent keybinding. */
7389 s = concat2 (s, tem);
7392 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
7393 if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
7395 /* Insert button prefix. */
7396 Lisp_Object selected
7397 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
7398 if (EQ (tem, QCradio))
7399 tem = build_string (NILP (selected) ? "(*) " : "( ) ");
7400 else
7401 tem = build_string (NILP (selected) ? "[X] " : "[ ] ");
7402 s = concat2 (tem, s);
7406 /* If we have room for the prompt string, add it to this line.
7407 If this is the first on the line, always add it. */
7408 if ((XSTRING (s)->size + i + 2
7409 + (char_matches ? 0 : XSTRING (desc)->size + 3))
7410 < width
7411 || !notfirst)
7413 int thiswidth;
7415 /* Punctuate between strings. */
7416 if (notfirst)
7418 strcpy (menu + i, ", ");
7419 i += 2;
7421 notfirst = 1;
7422 nobindings = 0 ;
7424 /* If the char to type doesn't match the string's
7425 first char, explicitly show what char to type. */
7426 if (! char_matches)
7428 /* Add as much of string as fits. */
7429 thiswidth = XSTRING (desc)->size;
7430 if (thiswidth + i > width)
7431 thiswidth = width - i;
7432 bcopy (XSTRING (desc)->data, menu + i, thiswidth);
7433 i += thiswidth;
7434 strcpy (menu + i, " = ");
7435 i += 3;
7438 /* Add as much of string as fits. */
7439 thiswidth = XSTRING (s)->size;
7440 if (thiswidth + i > width)
7441 thiswidth = width - i;
7442 bcopy (XSTRING (s)->data, menu + i, thiswidth);
7443 i += thiswidth;
7444 menu[i] = 0;
7446 else
7448 /* If this element does not fit, end the line now,
7449 and save the element for the next line. */
7450 strcpy (menu + i, "...");
7451 break;
7455 /* Move past this element. */
7456 if (idx >= 0 && idx + 1 >= XVECTOR (vector)->size)
7457 /* Handle reaching end of dense table. */
7458 idx = -1;
7459 if (idx >= 0)
7460 idx++;
7461 else
7462 rest = Fcdr_safe (rest);
7466 /* Prompt with that and read response. */
7467 message2_nolog (menu, strlen (menu),
7468 ! NILP (current_buffer->enable_multibyte_characters));
7470 /* Make believe its not a keyboard macro in case the help char
7471 is pressed. Help characters are not recorded because menu prompting
7472 is not used on replay.
7474 orig_defn_macro = current_kboard->defining_kbd_macro;
7475 current_kboard->defining_kbd_macro = Qnil;
7477 obj = read_char (commandflag, 0, 0, Qnil, 0);
7478 while (BUFFERP (obj));
7479 current_kboard->defining_kbd_macro = orig_defn_macro;
7481 if (!INTEGERP (obj))
7482 return obj;
7483 else
7484 ch = XINT (obj);
7486 if (! EQ (obj, menu_prompt_more_char)
7487 && (!INTEGERP (menu_prompt_more_char)
7488 || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
7490 if (!NILP (current_kboard->defining_kbd_macro))
7491 store_kbd_macro_char (obj);
7492 return obj;
7494 /* Help char - go round again */
7498 /* Reading key sequences. */
7500 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
7501 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
7502 keymap, or nil otherwise. Return the index of the first keymap in
7503 which KEY has any binding, or NMAPS if no map has a binding.
7505 If KEY is a meta ASCII character, treat it like meta-prefix-char
7506 followed by the corresponding non-meta character. Keymaps in
7507 CURRENT with non-prefix bindings for meta-prefix-char become nil in
7508 NEXT.
7510 If KEY has no bindings in any of the CURRENT maps, NEXT is left
7511 unmodified.
7513 NEXT may be the same array as CURRENT. */
7515 static int
7516 follow_key (key, nmaps, current, defs, next)
7517 Lisp_Object key;
7518 Lisp_Object *current, *defs, *next;
7519 int nmaps;
7521 int i, first_binding;
7522 int did_meta = 0;
7524 /* If KEY is a meta ASCII character, treat it like meta-prefix-char
7525 followed by the corresponding non-meta character.
7526 Put the results into DEFS, since we are going to alter that anyway.
7527 Do not alter CURRENT or NEXT. */
7528 if (INTEGERP (key) && (XUINT (key) & CHAR_META))
7530 for (i = 0; i < nmaps; i++)
7531 if (! NILP (current[i]))
7533 Lisp_Object def;
7534 def = get_keyelt (access_keymap (current[i],
7535 meta_prefix_char, 1, 0), 0);
7537 /* Note that since we pass the resulting bindings through
7538 get_keymap_1, non-prefix bindings for meta-prefix-char
7539 disappear. */
7540 defs[i] = get_keymap_1 (def, 0, 1);
7542 else
7543 defs[i] = Qnil;
7545 did_meta = 1;
7546 XSETINT (key, XFASTINT (key) & ~CHAR_META);
7549 first_binding = nmaps;
7550 for (i = nmaps - 1; i >= 0; i--)
7552 if (! NILP (current[i]))
7554 Lisp_Object map;
7555 if (did_meta)
7556 map = defs[i];
7557 else
7558 map = current[i];
7560 defs[i] = get_keyelt (access_keymap (map, key, 1, 0), 1);
7561 if (! NILP (defs[i]))
7562 first_binding = i;
7564 else
7565 defs[i] = Qnil;
7568 /* Given the set of bindings we've found, produce the next set of maps. */
7569 if (first_binding < nmaps)
7570 for (i = 0; i < nmaps; i++)
7571 next[i] = NILP (defs[i]) ? Qnil : get_keymap_1 (defs[i], 0, 1);
7573 return first_binding;
7576 /* Read a sequence of keys that ends with a non prefix character,
7577 storing it in KEYBUF, a buffer of size BUFSIZE.
7578 Prompt with PROMPT.
7579 Return the length of the key sequence stored.
7580 Return -1 if the user rejected a command menu.
7582 Echo starting immediately unless `prompt' is 0.
7584 Where a key sequence ends depends on the currently active keymaps.
7585 These include any minor mode keymaps active in the current buffer,
7586 the current buffer's local map, and the global map.
7588 If a key sequence has no other bindings, we check Vfunction_key_map
7589 to see if some trailing subsequence might be the beginning of a
7590 function key's sequence. If so, we try to read the whole function
7591 key, and substitute its symbolic name into the key sequence.
7593 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
7594 `double-' events into similar click events, if that would make them
7595 bound. We try to turn `triple-' events first into `double-' events,
7596 then into clicks.
7598 If we get a mouse click in a mode line, vertical divider, or other
7599 non-text area, we treat the click as if it were prefixed by the
7600 symbol denoting that area - `mode-line', `vertical-line', or
7601 whatever.
7603 If the sequence starts with a mouse click, we read the key sequence
7604 with respect to the buffer clicked on, not the current buffer.
7606 If the user switches frames in the midst of a key sequence, we put
7607 off the switch-frame event until later; the next call to
7608 read_char will return it.
7610 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
7611 from the selected window's buffer. */
7613 static int
7614 read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
7615 can_return_switch_frame, fix_current_buffer)
7616 Lisp_Object *keybuf;
7617 int bufsize;
7618 Lisp_Object prompt;
7619 int dont_downcase_last;
7620 int can_return_switch_frame;
7621 int fix_current_buffer;
7623 int count = specpdl_ptr - specpdl;
7625 /* How many keys there are in the current key sequence. */
7626 int t;
7628 /* The length of the echo buffer when we started reading, and
7629 the length of this_command_keys when we started reading. */
7630 int echo_start;
7631 int keys_start;
7633 /* The number of keymaps we're scanning right now, and the number of
7634 keymaps we have allocated space for. */
7635 int nmaps;
7636 int nmaps_allocated = 0;
7638 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
7639 the current keymaps. */
7640 Lisp_Object *defs;
7642 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7643 in the current keymaps, or nil where it is not a prefix. */
7644 Lisp_Object *submaps;
7646 /* The local map to start out with at start of key sequence. */
7647 Lisp_Object orig_local_map;
7649 /* The map from the `keymap' property to start out with at start of
7650 key sequence. */
7651 Lisp_Object orig_keymap;
7653 /* 1 if we have already considered switching to the local-map property
7654 of the place where a mouse click occurred. */
7655 int localized_local_map = 0;
7657 /* The index in defs[] of the first keymap that has a binding for
7658 this key sequence. In other words, the lowest i such that
7659 defs[i] is non-nil. */
7660 int first_binding;
7662 /* If t < mock_input, then KEYBUF[t] should be read as the next
7663 input key.
7665 We use this to recover after recognizing a function key. Once we
7666 realize that a suffix of the current key sequence is actually a
7667 function key's escape sequence, we replace the suffix with the
7668 function key's binding from Vfunction_key_map. Now keybuf
7669 contains a new and different key sequence, so the echo area,
7670 this_command_keys, and the submaps and defs arrays are wrong. In
7671 this situation, we set mock_input to t, set t to 0, and jump to
7672 restart_sequence; the loop will read keys from keybuf up until
7673 mock_input, thus rebuilding the state; and then it will resume
7674 reading characters from the keyboard. */
7675 int mock_input = 0;
7677 /* If the sequence is unbound in submaps[], then
7678 keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
7679 and fkey_map is its binding.
7681 These might be > t, indicating that all function key scanning
7682 should hold off until t reaches them. We do this when we've just
7683 recognized a function key, to avoid searching for the function
7684 key's again in Vfunction_key_map. */
7685 int fkey_start = 0, fkey_end = 0;
7686 Lisp_Object fkey_map;
7688 /* Likewise, for key_translation_map. */
7689 int keytran_start = 0, keytran_end = 0;
7690 Lisp_Object keytran_map;
7692 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
7693 we put it off for later. While we're reading, we keep the event here. */
7694 Lisp_Object delayed_switch_frame;
7696 /* See the comment below... */
7697 #if defined (GOBBLE_FIRST_EVENT)
7698 Lisp_Object first_event;
7699 #endif
7701 Lisp_Object original_uppercase;
7702 int original_uppercase_position = -1;
7704 /* Gets around Microsoft compiler limitations. */
7705 int dummyflag = 0;
7707 struct buffer *starting_buffer;
7709 /* Nonzero if we seem to have got the beginning of a binding
7710 in function_key_map. */
7711 int function_key_possible = 0;
7712 int key_translation_possible = 0;
7714 /* Save the status of key translation before each step,
7715 so that we can restore this after downcasing. */
7716 Lisp_Object prev_fkey_map;
7717 int prev_fkey_start;
7718 int prev_fkey_end;
7720 Lisp_Object prev_keytran_map;
7721 int prev_keytran_start;
7722 int prev_keytran_end;
7724 #if defined (GOBBLE_FIRST_EVENT)
7725 int junk;
7726 #endif
7728 raw_keybuf_count = 0;
7730 last_nonmenu_event = Qnil;
7732 delayed_switch_frame = Qnil;
7733 fkey_map = Vfunction_key_map;
7734 keytran_map = Vkey_translation_map;
7736 /* If there is no function-key-map, turn off function key scanning. */
7737 if (NILP (Fkeymapp (Vfunction_key_map)))
7738 fkey_start = fkey_end = bufsize + 1;
7740 /* If there is no key-translation-map, turn off scanning. */
7741 if (NILP (Fkeymapp (Vkey_translation_map)))
7742 keytran_start = keytran_end = bufsize + 1;
7744 if (INTERACTIVE)
7746 if (!NILP (prompt))
7747 echo_prompt (XSTRING (prompt)->data);
7748 else if (cursor_in_echo_area
7749 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
7750 && NILP (Fzerop (Vecho_keystrokes)))
7751 /* This doesn't put in a dash if the echo buffer is empty, so
7752 you don't always see a dash hanging out in the minibuffer. */
7753 echo_dash ();
7756 /* Record the initial state of the echo area and this_command_keys;
7757 we will need to restore them if we replay a key sequence. */
7758 if (INTERACTIVE)
7759 echo_start = echo_length ();
7760 keys_start = this_command_key_count;
7761 this_single_command_key_start = keys_start;
7763 #if defined (GOBBLE_FIRST_EVENT)
7764 /* This doesn't quite work, because some of the things that read_char
7765 does cannot safely be bypassed. It seems too risky to try to make
7766 this work right. */
7768 /* Read the first char of the sequence specially, before setting
7769 up any keymaps, in case a filter runs and switches buffers on us. */
7770 first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
7771 &junk);
7772 #endif /* GOBBLE_FIRST_EVENT */
7774 orig_local_map = get_local_map (PT, current_buffer, local_map);
7775 orig_keymap = get_local_map (PT, current_buffer, keymap);
7777 /* We jump here when the key sequence has been thoroughly changed, and
7778 we need to rescan it starting from the beginning. When we jump here,
7779 keybuf[0..mock_input] holds the sequence we should reread. */
7780 replay_sequence:
7782 starting_buffer = current_buffer;
7783 function_key_possible = 0;
7784 key_translation_possible = 0;
7786 /* Build our list of keymaps.
7787 If we recognize a function key and replace its escape sequence in
7788 keybuf with its symbol, or if the sequence starts with a mouse
7789 click and we need to switch buffers, we jump back here to rebuild
7790 the initial keymaps from the current buffer. */
7792 Lisp_Object *maps;
7794 if (!NILP (current_kboard->Voverriding_terminal_local_map)
7795 || !NILP (Voverriding_local_map))
7797 if (3 > nmaps_allocated)
7799 submaps = (Lisp_Object *) alloca (3 * sizeof (submaps[0]));
7800 defs = (Lisp_Object *) alloca (3 * sizeof (defs[0]));
7801 nmaps_allocated = 3;
7803 nmaps = 0;
7804 if (!NILP (current_kboard->Voverriding_terminal_local_map))
7805 submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
7806 if (!NILP (Voverriding_local_map))
7807 submaps[nmaps++] = Voverriding_local_map;
7809 else
7811 int extra_maps = 2;
7812 nmaps = current_minor_maps (0, &maps);
7813 if (!NILP (orig_keymap))
7814 extra_maps = 3;
7815 if (nmaps + extra_maps > nmaps_allocated)
7817 submaps = (Lisp_Object *) alloca ((nmaps+extra_maps)
7818 * sizeof (submaps[0]));
7819 defs = (Lisp_Object *) alloca ((nmaps+extra_maps)
7820 * sizeof (defs[0]));
7821 nmaps_allocated = nmaps + extra_maps;
7823 bcopy (maps, submaps, nmaps * sizeof (submaps[0]));
7824 if (!NILP (orig_keymap))
7825 submaps[nmaps++] = orig_keymap;
7826 submaps[nmaps++] = orig_local_map;
7828 submaps[nmaps++] = current_global_map;
7831 /* Find an accurate initial value for first_binding. */
7832 for (first_binding = 0; first_binding < nmaps; first_binding++)
7833 if (! NILP (submaps[first_binding]))
7834 break;
7836 /* Start from the beginning in keybuf. */
7837 t = 0;
7839 /* These are no-ops the first time through, but if we restart, they
7840 revert the echo area and this_command_keys to their original state. */
7841 this_command_key_count = keys_start;
7842 if (INTERACTIVE && t < mock_input)
7843 echo_truncate (echo_start);
7845 /* If the best binding for the current key sequence is a keymap, or
7846 we may be looking at a function key's escape sequence, keep on
7847 reading. */
7848 while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
7849 || (first_binding >= nmaps
7850 && fkey_start < t
7851 /* mock input is never part of a function key's sequence. */
7852 && mock_input <= fkey_start)
7853 || (first_binding >= nmaps
7854 && keytran_start < t && key_translation_possible)
7855 /* Don't return in the middle of a possible function key sequence,
7856 if the only bindings we found were via case conversion.
7857 Thus, if ESC O a has a function-key-map translation
7858 and ESC o has a binding, don't return after ESC O,
7859 so that we can translate ESC O plus the next character. */
7862 Lisp_Object key;
7863 int used_mouse_menu = 0;
7865 /* Where the last real key started. If we need to throw away a
7866 key that has expanded into more than one element of keybuf
7867 (say, a mouse click on the mode line which is being treated
7868 as [mode-line (mouse-...)], then we backtrack to this point
7869 of keybuf. */
7870 int last_real_key_start;
7872 /* These variables are analogous to echo_start and keys_start;
7873 while those allow us to restart the entire key sequence,
7874 echo_local_start and keys_local_start allow us to throw away
7875 just one key. */
7876 int echo_local_start, keys_local_start, local_first_binding;
7878 if (t >= bufsize)
7879 error ("Key sequence too long");
7881 if (INTERACTIVE)
7882 echo_local_start = echo_length ();
7883 keys_local_start = this_command_key_count;
7884 local_first_binding = first_binding;
7886 replay_key:
7887 /* These are no-ops, unless we throw away a keystroke below and
7888 jumped back up to replay_key; in that case, these restore the
7889 variables to their original state, allowing us to replay the
7890 loop. */
7891 if (INTERACTIVE && t < mock_input)
7892 echo_truncate (echo_local_start);
7893 this_command_key_count = keys_local_start;
7894 first_binding = local_first_binding;
7896 /* By default, assume each event is "real". */
7897 last_real_key_start = t;
7899 /* Does mock_input indicate that we are re-reading a key sequence? */
7900 if (t < mock_input)
7902 key = keybuf[t];
7903 add_command_key (key);
7904 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
7905 && NILP (Fzerop (Vecho_keystrokes)))
7906 echo_char (key);
7909 /* If not, we should actually read a character. */
7910 else
7913 #ifdef MULTI_KBOARD
7914 KBOARD *interrupted_kboard = current_kboard;
7915 struct frame *interrupted_frame = SELECTED_FRAME ();
7916 if (setjmp (wrong_kboard_jmpbuf))
7918 if (!NILP (delayed_switch_frame))
7920 interrupted_kboard->kbd_queue
7921 = Fcons (delayed_switch_frame,
7922 interrupted_kboard->kbd_queue);
7923 delayed_switch_frame = Qnil;
7925 while (t > 0)
7926 interrupted_kboard->kbd_queue
7927 = Fcons (keybuf[--t], interrupted_kboard->kbd_queue);
7929 /* If the side queue is non-empty, ensure it begins with a
7930 switch-frame, so we'll replay it in the right context. */
7931 if (CONSP (interrupted_kboard->kbd_queue)
7932 && (key = XCAR (interrupted_kboard->kbd_queue),
7933 !(EVENT_HAS_PARAMETERS (key)
7934 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)),
7935 Qswitch_frame))))
7937 Lisp_Object frame;
7938 XSETFRAME (frame, interrupted_frame);
7939 interrupted_kboard->kbd_queue
7940 = Fcons (make_lispy_switch_frame (frame),
7941 interrupted_kboard->kbd_queue);
7943 mock_input = 0;
7944 orig_local_map = get_local_map (PT, current_buffer, local_map);
7945 orig_keymap = get_local_map (PT, current_buffer, keymap);
7946 goto replay_sequence;
7948 #endif
7949 key = read_char (NILP (prompt), nmaps, submaps, last_nonmenu_event,
7950 &used_mouse_menu);
7953 /* read_char returns t when it shows a menu and the user rejects it.
7954 Just return -1. */
7955 if (EQ (key, Qt))
7957 unbind_to (count, Qnil);
7958 return -1;
7961 /* read_char returns -1 at the end of a macro.
7962 Emacs 18 handles this by returning immediately with a
7963 zero, so that's what we'll do. */
7964 if (INTEGERP (key) && XINT (key) == -1)
7966 t = 0;
7967 /* The Microsoft C compiler can't handle the goto that
7968 would go here. */
7969 dummyflag = 1;
7970 break;
7973 /* If the current buffer has been changed from under us, the
7974 keymap may have changed, so replay the sequence. */
7975 if (BUFFERP (key))
7977 mock_input = t;
7978 /* Reset the current buffer from the selected window
7979 in case something changed the former and not the latter.
7980 This is to be more consistent with the behavior
7981 of the command_loop_1. */
7982 if (fix_current_buffer)
7984 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
7985 Fkill_emacs (Qnil);
7986 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
7987 Fset_buffer (XWINDOW (selected_window)->buffer);
7990 orig_local_map = get_local_map (PT, current_buffer, local_map);
7991 orig_keymap = get_local_map (PT, current_buffer, keymap);
7992 goto replay_sequence;
7995 /* If we have a quit that was typed in another frame, and
7996 quit_throw_to_read_char switched buffers,
7997 replay to get the right keymap. */
7998 if (XINT (key) == quit_char && current_buffer != starting_buffer)
8000 GROW_RAW_KEYBUF;
8001 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8002 keybuf[t++] = key;
8003 mock_input = t;
8004 Vquit_flag = Qnil;
8005 orig_local_map = get_local_map (PT, current_buffer, local_map);
8006 orig_keymap = get_local_map (PT, current_buffer, keymap);
8007 goto replay_sequence;
8010 Vquit_flag = Qnil;
8012 if (EVENT_HAS_PARAMETERS (key)
8013 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)), Qswitch_frame))
8015 /* If we're at the beginning of a key sequence, and the caller
8016 says it's okay, go ahead and return this event. If we're
8017 in the midst of a key sequence, delay it until the end. */
8018 if (t > 0 || !can_return_switch_frame)
8020 delayed_switch_frame = key;
8021 goto replay_key;
8025 GROW_RAW_KEYBUF;
8026 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8029 /* Clicks in non-text areas get prefixed by the symbol
8030 in their CHAR-ADDRESS field. For example, a click on
8031 the mode line is prefixed by the symbol `mode-line'.
8033 Furthermore, key sequences beginning with mouse clicks
8034 are read using the keymaps of the buffer clicked on, not
8035 the current buffer. So we may have to switch the buffer
8036 here.
8038 When we turn one event into two events, we must make sure
8039 that neither of the two looks like the original--so that,
8040 if we replay the events, they won't be expanded again.
8041 If not for this, such reexpansion could happen either here
8042 or when user programs play with this-command-keys. */
8043 if (EVENT_HAS_PARAMETERS (key))
8045 Lisp_Object kind;
8047 kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
8048 if (EQ (kind, Qmouse_click))
8050 Lisp_Object window, posn;
8052 window = POSN_WINDOW (EVENT_START (key));
8053 posn = POSN_BUFFER_POSN (EVENT_START (key));
8055 if (CONSP (posn))
8057 /* We're looking at the second event of a
8058 sequence which we expanded before. Set
8059 last_real_key_start appropriately. */
8060 if (t > 0)
8061 last_real_key_start = t - 1;
8064 /* Key sequences beginning with mouse clicks are
8065 read using the keymaps in the buffer clicked on,
8066 not the current buffer. If we're at the
8067 beginning of a key sequence, switch buffers. */
8068 if (last_real_key_start == 0
8069 && WINDOWP (window)
8070 && BUFFERP (XWINDOW (window)->buffer)
8071 && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
8073 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8074 keybuf[t] = key;
8075 mock_input = t + 1;
8077 /* Arrange to go back to the original buffer once we're
8078 done reading the key sequence. Note that we can't
8079 use save_excursion_{save,restore} here, because they
8080 save point as well as the current buffer; we don't
8081 want to save point, because redisplay may change it,
8082 to accommodate a Fset_window_start or something. We
8083 don't want to do this at the top of the function,
8084 because we may get input from a subprocess which
8085 wants to change the selected window and stuff (say,
8086 emacsclient). */
8087 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
8089 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
8090 Fkill_emacs (Qnil);
8091 set_buffer_internal (XBUFFER (XWINDOW
8092 (window)->buffer)
8094 orig_local_map = get_local_map (PT, current_buffer,
8095 local_map);
8096 orig_keymap = get_local_map (PT, current_buffer, keymap);
8097 goto replay_sequence;
8100 /* For a mouse click, get the local text-property keymap
8101 of the place clicked on, rather than point. */
8102 if (last_real_key_start == 0
8103 && CONSP (XCDR (key))
8104 && ! localized_local_map)
8106 Lisp_Object map_here, start, pos;
8108 localized_local_map = 1;
8109 start = EVENT_START (key);
8111 if (CONSP (start) && CONSP (XCDR (start)))
8113 pos = POSN_BUFFER_POSN (start);
8114 if (INTEGERP (pos)
8115 && XINT (pos) >= BEG && XINT (pos) <= Z)
8117 map_here = get_local_map (XINT (pos),
8118 current_buffer, local_map);
8119 if (!EQ (map_here, orig_local_map))
8121 orig_local_map = map_here;
8122 keybuf[t] = key;
8123 mock_input = t + 1;
8125 goto replay_sequence;
8127 map_here = get_local_map (XINT (pos),
8128 current_buffer, keymap);
8129 if (!EQ (map_here, orig_keymap))
8131 orig_keymap = map_here;
8132 keybuf[t] = key;
8133 mock_input = t + 1;
8135 goto replay_sequence;
8141 /* Expand mode-line and scroll-bar events into two events:
8142 use posn as a fake prefix key. */
8143 if (SYMBOLP (posn))
8145 if (t + 1 >= bufsize)
8146 error ("Key sequence too long");
8147 keybuf[t] = posn;
8148 keybuf[t+1] = key;
8149 mock_input = t + 2;
8151 /* Zap the position in key, so we know that we've
8152 expanded it, and don't try to do so again. */
8153 POSN_BUFFER_POSN (EVENT_START (key))
8154 = Fcons (posn, Qnil);
8156 /* If on a mode line string with a local keymap,
8157 reconsider the key sequence with that keymap. */
8158 if (CONSP (POSN_STRING (EVENT_START (key))))
8160 Lisp_Object string, pos, map, map2;
8162 string = POSN_STRING (EVENT_START (key));
8163 pos = XCDR (string);
8164 string = XCAR (string);
8165 if (XINT (pos) >= 0
8166 && XINT (pos) < XSTRING (string)->size)
8168 map = Fget_text_property (pos, Qlocal_map, string);
8169 if (!NILP (map))
8170 orig_local_map = map;
8171 map2 = Fget_text_property (pos, Qkeymap, string);
8172 if (!NILP (map2))
8173 orig_keymap = map2;
8174 if (!NILP (map) || !NILP (map2))
8175 goto replay_sequence;
8179 goto replay_key;
8182 else if (CONSP (XCDR (key))
8183 && CONSP (EVENT_START (key))
8184 && CONSP (XCDR (EVENT_START (key))))
8186 Lisp_Object posn;
8188 posn = POSN_BUFFER_POSN (EVENT_START (key));
8189 /* Handle menu-bar events:
8190 insert the dummy prefix event `menu-bar'. */
8191 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
8193 if (t + 1 >= bufsize)
8194 error ("Key sequence too long");
8195 keybuf[t] = posn;
8196 keybuf[t+1] = key;
8198 /* Zap the position in key, so we know that we've
8199 expanded it, and don't try to do so again. */
8200 POSN_BUFFER_POSN (EVENT_START (key))
8201 = Fcons (posn, Qnil);
8203 mock_input = t + 2;
8204 goto replay_sequence;
8206 else if (CONSP (posn))
8208 /* We're looking at the second event of a
8209 sequence which we expanded before. Set
8210 last_real_key_start appropriately. */
8211 if (last_real_key_start == t && t > 0)
8212 last_real_key_start = t - 1;
8217 /* We have finally decided that KEY is something we might want
8218 to look up. */
8219 first_binding = (follow_key (key,
8220 nmaps - first_binding,
8221 submaps + first_binding,
8222 defs + first_binding,
8223 submaps + first_binding)
8224 + first_binding);
8226 /* If KEY wasn't bound, we'll try some fallbacks. */
8227 if (first_binding >= nmaps)
8229 Lisp_Object head;
8231 head = EVENT_HEAD (key);
8232 if (help_char_p (head) && t > 0)
8234 read_key_sequence_cmd = Vprefix_help_command;
8235 keybuf[t++] = key;
8236 last_nonmenu_event = key;
8237 /* The Microsoft C compiler can't handle the goto that
8238 would go here. */
8239 dummyflag = 1;
8240 break;
8243 if (SYMBOLP (head))
8245 Lisp_Object breakdown;
8246 int modifiers;
8248 breakdown = parse_modifiers (head);
8249 modifiers = XINT (XCAR (XCDR (breakdown)));
8250 /* Attempt to reduce an unbound mouse event to a simpler
8251 event that is bound:
8252 Drags reduce to clicks.
8253 Double-clicks reduce to clicks.
8254 Triple-clicks reduce to double-clicks, then to clicks.
8255 Down-clicks are eliminated.
8256 Double-downs reduce to downs, then are eliminated.
8257 Triple-downs reduce to double-downs, then to downs,
8258 then are eliminated. */
8259 if (modifiers & (down_modifier | drag_modifier
8260 | double_modifier | triple_modifier))
8262 while (modifiers & (down_modifier | drag_modifier
8263 | double_modifier | triple_modifier))
8265 Lisp_Object new_head, new_click;
8266 if (modifiers & triple_modifier)
8267 modifiers ^= (double_modifier | triple_modifier);
8268 else if (modifiers & double_modifier)
8269 modifiers &= ~double_modifier;
8270 else if (modifiers & drag_modifier)
8271 modifiers &= ~drag_modifier;
8272 else
8274 /* Dispose of this `down' event by simply jumping
8275 back to replay_key, to get another event.
8277 Note that if this event came from mock input,
8278 then just jumping back to replay_key will just
8279 hand it to us again. So we have to wipe out any
8280 mock input.
8282 We could delete keybuf[t] and shift everything
8283 after that to the left by one spot, but we'd also
8284 have to fix up any variable that points into
8285 keybuf, and shifting isn't really necessary
8286 anyway.
8288 Adding prefixes for non-textual mouse clicks
8289 creates two characters of mock input, and both
8290 must be thrown away. If we're only looking at
8291 the prefix now, we can just jump back to
8292 replay_key. On the other hand, if we've already
8293 processed the prefix, and now the actual click
8294 itself is giving us trouble, then we've lost the
8295 state of the keymaps we want to backtrack to, and
8296 we need to replay the whole sequence to rebuild
8299 Beyond that, only function key expansion could
8300 create more than two keys, but that should never
8301 generate mouse events, so it's okay to zero
8302 mock_input in that case too.
8304 Isn't this just the most wonderful code ever? */
8305 if (t == last_real_key_start)
8307 mock_input = 0;
8308 goto replay_key;
8310 else
8312 mock_input = last_real_key_start;
8313 goto replay_sequence;
8317 new_head
8318 = apply_modifiers (modifiers, XCAR (breakdown));
8319 new_click
8320 = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
8322 /* Look for a binding for this new key. follow_key
8323 promises that it didn't munge submaps the
8324 last time we called it, since key was unbound. */
8325 first_binding
8326 = (follow_key (new_click,
8327 nmaps - local_first_binding,
8328 submaps + local_first_binding,
8329 defs + local_first_binding,
8330 submaps + local_first_binding)
8331 + local_first_binding);
8333 /* If that click is bound, go for it. */
8334 if (first_binding < nmaps)
8336 key = new_click;
8337 break;
8339 /* Otherwise, we'll leave key set to the drag event. */
8345 keybuf[t++] = key;
8346 /* Normally, last_nonmenu_event gets the previous key we read.
8347 But when a mouse popup menu is being used,
8348 we don't update last_nonmenu_event; it continues to hold the mouse
8349 event that preceded the first level of menu. */
8350 if (!used_mouse_menu)
8351 last_nonmenu_event = key;
8353 /* Record what part of this_command_keys is the current key sequence. */
8354 this_single_command_key_start = this_command_key_count - t;
8356 prev_fkey_map = fkey_map;
8357 prev_fkey_start = fkey_start;
8358 prev_fkey_end = fkey_end;
8360 prev_keytran_map = keytran_map;
8361 prev_keytran_start = keytran_start;
8362 prev_keytran_end = keytran_end;
8364 /* If the sequence is unbound, see if we can hang a function key
8365 off the end of it. We only want to scan real keyboard input
8366 for function key sequences, so if mock_input says that we're
8367 re-reading old events, don't examine it. */
8368 if (first_binding >= nmaps
8369 && t >= mock_input)
8371 Lisp_Object fkey_next;
8373 /* Continue scan from fkey_end until we find a bound suffix.
8374 If we fail, increment fkey_start
8375 and start fkey_end from there. */
8376 while (fkey_end < t)
8378 Lisp_Object key;
8380 key = keybuf[fkey_end++];
8381 /* Look up meta-characters by prefixing them
8382 with meta_prefix_char. I hate this. */
8383 if (INTEGERP (key) && XUINT (key) & meta_modifier)
8385 fkey_next
8386 = get_keymap_1
8387 (get_keyelt
8388 (access_keymap (fkey_map, meta_prefix_char, 1, 0), 0),
8389 0, 1);
8390 XSETFASTINT (key, XFASTINT (key) & ~meta_modifier);
8392 else
8393 fkey_next = fkey_map;
8395 fkey_next
8396 = get_keyelt (access_keymap (fkey_next, key, 1, 0), 1);
8398 /* Handle symbol with autoload definition. */
8399 if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
8400 && CONSP (XSYMBOL (fkey_next)->function)
8401 && EQ (XCAR (XSYMBOL (fkey_next)->function), Qautoload))
8402 do_autoload (XSYMBOL (fkey_next)->function,
8403 fkey_next);
8405 /* Handle a symbol whose function definition is a keymap
8406 or an array. */
8407 if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
8408 && (!NILP (Farrayp (XSYMBOL (fkey_next)->function))
8409 || !NILP (Fkeymapp (XSYMBOL (fkey_next)->function))))
8410 fkey_next = XSYMBOL (fkey_next)->function;
8412 #if 0 /* I didn't turn this on, because it might cause trouble
8413 for the mapping of return into C-m and tab into C-i. */
8414 /* Optionally don't map function keys into other things.
8415 This enables the user to redefine kp- keys easily. */
8416 if (SYMBOLP (key) && !NILP (Vinhibit_function_key_mapping))
8417 fkey_next = Qnil;
8418 #endif
8420 /* If the function key map gives a function, not an
8421 array, then call the function with no args and use
8422 its value instead. */
8423 if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
8424 && fkey_end == t)
8426 struct gcpro gcpro1, gcpro2, gcpro3;
8427 Lisp_Object tem;
8428 tem = fkey_next;
8430 GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
8431 fkey_next = call1 (fkey_next, prompt);
8432 UNGCPRO;
8433 /* If the function returned something invalid,
8434 barf--don't ignore it.
8435 (To ignore it safely, we would need to gcpro a bunch of
8436 other variables.) */
8437 if (! (VECTORP (fkey_next) || STRINGP (fkey_next)))
8438 error ("Function in key-translation-map returns invalid key sequence");
8441 function_key_possible = ! NILP (fkey_next);
8443 /* If keybuf[fkey_start..fkey_end] is bound in the
8444 function key map and it's a suffix of the current
8445 sequence (i.e. fkey_end == t), replace it with
8446 the binding and restart with fkey_start at the end. */
8447 if ((VECTORP (fkey_next) || STRINGP (fkey_next))
8448 && fkey_end == t)
8450 int len = XFASTINT (Flength (fkey_next));
8452 t = fkey_start + len;
8453 if (t >= bufsize)
8454 error ("Key sequence too long");
8456 if (VECTORP (fkey_next))
8457 bcopy (XVECTOR (fkey_next)->contents,
8458 keybuf + fkey_start,
8459 (t - fkey_start) * sizeof (keybuf[0]));
8460 else if (STRINGP (fkey_next))
8462 int i;
8464 for (i = 0; i < len; i++)
8465 XSETFASTINT (keybuf[fkey_start + i],
8466 XSTRING (fkey_next)->data[i]);
8469 mock_input = t;
8470 fkey_start = fkey_end = t;
8471 fkey_map = Vfunction_key_map;
8473 /* Do pass the results through key-translation-map.
8474 But don't retranslate what key-translation-map
8475 has already translated. */
8476 keytran_end = keytran_start;
8477 keytran_map = Vkey_translation_map;
8479 goto replay_sequence;
8482 fkey_map = get_keymap_1 (fkey_next, 0, 1);
8484 /* If we no longer have a bound suffix, try a new positions for
8485 fkey_start. */
8486 if (NILP (fkey_map))
8488 fkey_end = ++fkey_start;
8489 fkey_map = Vfunction_key_map;
8490 function_key_possible = 0;
8495 /* Look for this sequence in key-translation-map. */
8497 Lisp_Object keytran_next;
8499 /* Scan from keytran_end until we find a bound suffix. */
8500 while (keytran_end < t)
8502 Lisp_Object key;
8504 key = keybuf[keytran_end++];
8505 /* Look up meta-characters by prefixing them
8506 with meta_prefix_char. I hate this. */
8507 if (INTEGERP (key) && XUINT (key) & meta_modifier)
8509 keytran_next
8510 = get_keymap_1
8511 (get_keyelt
8512 (access_keymap (keytran_map, meta_prefix_char, 1, 0), 0),
8513 0, 1);
8514 XSETFASTINT (key, XFASTINT (key) & ~meta_modifier);
8516 else
8517 keytran_next = keytran_map;
8519 keytran_next
8520 = get_keyelt (access_keymap (keytran_next, key, 1, 0), 1);
8522 /* Handle symbol with autoload definition. */
8523 if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
8524 && CONSP (XSYMBOL (keytran_next)->function)
8525 && EQ (XCAR (XSYMBOL (keytran_next)->function), Qautoload))
8526 do_autoload (XSYMBOL (keytran_next)->function,
8527 keytran_next);
8529 /* Handle a symbol whose function definition is a keymap
8530 or an array. */
8531 if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
8532 && (!NILP (Farrayp (XSYMBOL (keytran_next)->function))
8533 || !NILP (Fkeymapp (XSYMBOL (keytran_next)->function))))
8534 keytran_next = XSYMBOL (keytran_next)->function;
8536 /* If the key translation map gives a function, not an
8537 array, then call the function with one arg and use
8538 its value instead. */
8539 if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
8540 && keytran_end == t)
8542 struct gcpro gcpro1, gcpro2, gcpro3;
8543 Lisp_Object tem;
8544 tem = keytran_next;
8546 GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
8547 keytran_next = call1 (keytran_next, prompt);
8548 UNGCPRO;
8549 /* If the function returned something invalid,
8550 barf--don't ignore it.
8551 (To ignore it safely, we would need to gcpro a bunch of
8552 other variables.) */
8553 if (! (VECTORP (keytran_next) || STRINGP (keytran_next)))
8554 error ("Function in key-translation-map returns invalid key sequence");
8557 key_translation_possible = ! NILP (keytran_next);
8559 /* If keybuf[keytran_start..keytran_end] is bound in the
8560 key translation map and it's a suffix of the current
8561 sequence (i.e. keytran_end == t), replace it with
8562 the binding and restart with keytran_start at the end. */
8563 if ((VECTORP (keytran_next) || STRINGP (keytran_next))
8564 && keytran_end == t)
8566 int len = XFASTINT (Flength (keytran_next));
8568 t = keytran_start + len;
8569 if (t >= bufsize)
8570 error ("Key sequence too long");
8572 if (VECTORP (keytran_next))
8573 bcopy (XVECTOR (keytran_next)->contents,
8574 keybuf + keytran_start,
8575 (t - keytran_start) * sizeof (keybuf[0]));
8576 else if (STRINGP (keytran_next))
8578 int i;
8580 for (i = 0; i < len; i++)
8581 XSETFASTINT (keybuf[keytran_start + i],
8582 XSTRING (keytran_next)->data[i]);
8585 mock_input = t;
8586 keytran_start = keytran_end = t;
8587 keytran_map = Vkey_translation_map;
8589 /* Don't pass the results of key-translation-map
8590 through function-key-map. */
8591 fkey_start = fkey_end = t;
8592 fkey_map = Vfunction_key_map;
8594 goto replay_sequence;
8597 keytran_map = get_keymap_1 (keytran_next, 0, 1);
8599 /* If we no longer have a bound suffix, try a new positions for
8600 keytran_start. */
8601 if (NILP (keytran_map))
8603 keytran_end = ++keytran_start;
8604 keytran_map = Vkey_translation_map;
8605 key_translation_possible = 0;
8610 /* If KEY is not defined in any of the keymaps,
8611 and cannot be part of a function key or translation,
8612 and is an upper case letter
8613 use the corresponding lower-case letter instead. */
8614 if (first_binding == nmaps && ! function_key_possible
8615 && ! key_translation_possible
8616 && INTEGERP (key)
8617 && ((((XINT (key) & 0x3ffff)
8618 < XCHAR_TABLE (current_buffer->downcase_table)->size)
8619 && UPPERCASEP (XINT (key) & 0x3ffff))
8620 || (XINT (key) & shift_modifier)))
8622 Lisp_Object new_key;
8624 original_uppercase = key;
8625 original_uppercase_position = t - 1;
8627 if (XINT (key) & shift_modifier)
8628 XSETINT (new_key, XINT (key) & ~shift_modifier);
8629 else
8630 XSETINT (new_key, (DOWNCASE (XINT (key) & 0x3ffff)
8631 | (XINT (key) & ~0x3ffff)));
8633 /* We have to do this unconditionally, regardless of whether
8634 the lower-case char is defined in the keymaps, because they
8635 might get translated through function-key-map. */
8636 keybuf[t - 1] = new_key;
8637 mock_input = t;
8639 fkey_map = prev_fkey_map;
8640 fkey_start = prev_fkey_start;
8641 fkey_end = prev_fkey_end;
8643 keytran_map = prev_keytran_map;
8644 keytran_start = prev_keytran_start;
8645 keytran_end = prev_keytran_end;
8647 goto replay_sequence;
8649 /* If KEY is not defined in any of the keymaps,
8650 and cannot be part of a function key or translation,
8651 and is a shifted function key,
8652 use the corresponding unshifted function key instead. */
8653 if (first_binding == nmaps && ! function_key_possible
8654 && ! key_translation_possible
8655 && SYMBOLP (key))
8657 Lisp_Object breakdown;
8658 int modifiers;
8660 breakdown = parse_modifiers (key);
8661 modifiers = XINT (XCAR (XCDR (breakdown)));
8662 if (modifiers & shift_modifier)
8664 Lisp_Object new_key;
8666 original_uppercase = key;
8667 original_uppercase_position = t - 1;
8669 modifiers &= ~shift_modifier;
8670 new_key = apply_modifiers (modifiers,
8671 XCAR (breakdown));
8673 keybuf[t - 1] = new_key;
8674 mock_input = t;
8676 fkey_map = prev_fkey_map;
8677 fkey_start = prev_fkey_start;
8678 fkey_end = prev_fkey_end;
8680 keytran_map = prev_keytran_map;
8681 keytran_start = prev_keytran_start;
8682 keytran_end = prev_keytran_end;
8684 goto replay_sequence;
8689 if (!dummyflag)
8690 read_key_sequence_cmd = (first_binding < nmaps
8691 ? defs[first_binding]
8692 : Qnil);
8694 unread_switch_frame = delayed_switch_frame;
8695 unbind_to (count, Qnil);
8697 /* Don't downcase the last character if the caller says don't.
8698 Don't downcase it if the result is undefined, either. */
8699 if ((dont_downcase_last || first_binding >= nmaps)
8700 && t - 1 == original_uppercase_position)
8701 keybuf[t - 1] = original_uppercase;
8703 /* Occasionally we fabricate events, perhaps by expanding something
8704 according to function-key-map, or by adding a prefix symbol to a
8705 mouse click in the scroll bar or modeline. In this cases, return
8706 the entire generated key sequence, even if we hit an unbound
8707 prefix or a definition before the end. This means that you will
8708 be able to push back the event properly, and also means that
8709 read-key-sequence will always return a logical unit.
8711 Better ideas? */
8712 for (; t < mock_input; t++)
8714 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
8715 && NILP (Fzerop (Vecho_keystrokes)))
8716 echo_char (keybuf[t]);
8717 add_command_key (keybuf[t]);
8722 return t;
8725 #if 0 /* This doc string is too long for some compilers.
8726 This commented-out definition serves for DOC. */
8727 DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 4, 0,
8728 "Read a sequence of keystrokes and return as a string or vector.\n\
8729 The sequence is sufficient to specify a non-prefix command in the\n\
8730 current local and global maps.\n\
8732 First arg PROMPT is a prompt string. If nil, do not prompt specially.\n\
8733 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
8734 as a continuation of the previous key.\n\
8736 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not\n\
8737 convert the last event to lower case. (Normally any upper case event\n\
8738 is converted to lower case if the original event is undefined and the lower\n\
8739 case equivalent is defined.) A non-nil value is appropriate for reading\n\
8740 a key sequence to be defined.\n\
8742 A C-g typed while in this function is treated like any other character,\n\
8743 and `quit-flag' is not set.\n\
8745 If the key sequence starts with a mouse click, then the sequence is read\n\
8746 using the keymaps of the buffer of the window clicked in, not the buffer\n\
8747 of the selected window as normal.\n\
8748 ""\n\
8749 `read-key-sequence' drops unbound button-down events, since you normally\n\
8750 only care about the click or drag events which follow them. If a drag\n\
8751 or multi-click event is unbound, but the corresponding click event would\n\
8752 be bound, `read-key-sequence' turns the event into a click event at the\n\
8753 drag's starting position. This means that you don't have to distinguish\n\
8754 between click and drag, double, or triple events unless you want to.\n\
8756 `read-key-sequence' prefixes mouse events on mode lines, the vertical\n\
8757 lines separating windows, and scroll bars with imaginary keys\n\
8758 `mode-line', `vertical-line', and `vertical-scroll-bar'.\n\
8760 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this\n\
8761 function will process a switch-frame event if the user switches frames\n\
8762 before typing anything. If the user switches frames in the middle of a\n\
8763 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME\n\
8764 is nil, then the event will be put off until after the current key sequence.\n\
8766 `read-key-sequence' checks `function-key-map' for function key\n\
8767 sequences, where they wouldn't conflict with ordinary bindings. See\n\
8768 `function-key-map' for more details.\n\
8770 The optional fifth argument COMMAND-LOOP, if non-nil, means\n\
8771 that this key sequence is being read by something that will\n\
8772 read commands one after another. It should be nil if the caller\n\
8773 will read just one key sequence.")
8774 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame, command-loop)
8775 #endif
8777 DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 5, 0,
8779 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
8780 command_loop)
8781 Lisp_Object prompt, continue_echo, dont_downcase_last;
8782 Lisp_Object can_return_switch_frame, command_loop;
8784 Lisp_Object keybuf[30];
8785 register int i;
8786 struct gcpro gcpro1;
8787 int count = specpdl_ptr - specpdl;
8789 if (!NILP (prompt))
8790 CHECK_STRING (prompt, 0);
8791 QUIT;
8793 specbind (Qinput_method_exit_on_first_char,
8794 (NILP (command_loop) ? Qt : Qnil));
8795 specbind (Qinput_method_use_echo_area,
8796 (NILP (command_loop) ? Qt : Qnil));
8798 bzero (keybuf, sizeof keybuf);
8799 GCPRO1 (keybuf[0]);
8800 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
8802 if (NILP (continue_echo))
8804 this_command_key_count = 0;
8805 this_single_command_key_start = 0;
8808 #ifdef HAVE_X_WINDOWS
8809 if (display_busy_cursor_p)
8810 cancel_busy_cursor ();
8811 #endif
8813 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
8814 prompt, ! NILP (dont_downcase_last),
8815 ! NILP (can_return_switch_frame), 0);
8817 #ifdef HAVE_X_WINDOWS
8818 if (display_busy_cursor_p)
8819 start_busy_cursor ();
8820 #endif
8822 if (i == -1)
8824 Vquit_flag = Qt;
8825 QUIT;
8827 UNGCPRO;
8828 return unbind_to (count, make_event_array (i, keybuf));
8831 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
8832 Sread_key_sequence_vector, 1, 5, 0,
8833 "Like `read-key-sequence' but always return a vector.")
8834 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
8835 command_loop)
8836 Lisp_Object prompt, continue_echo, dont_downcase_last;
8837 Lisp_Object can_return_switch_frame, command_loop;
8839 Lisp_Object keybuf[30];
8840 register int i;
8841 struct gcpro gcpro1;
8842 int count = specpdl_ptr - specpdl;
8844 if (!NILP (prompt))
8845 CHECK_STRING (prompt, 0);
8846 QUIT;
8848 specbind (Qinput_method_exit_on_first_char,
8849 (NILP (command_loop) ? Qt : Qnil));
8850 specbind (Qinput_method_use_echo_area,
8851 (NILP (command_loop) ? Qt : Qnil));
8853 bzero (keybuf, sizeof keybuf);
8854 GCPRO1 (keybuf[0]);
8855 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
8857 if (NILP (continue_echo))
8859 this_command_key_count = 0;
8860 this_single_command_key_start = 0;
8863 #ifdef HAVE_X_WINDOWS
8864 if (display_busy_cursor_p)
8865 cancel_busy_cursor ();
8866 #endif
8868 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
8869 prompt, ! NILP (dont_downcase_last),
8870 ! NILP (can_return_switch_frame), 0);
8872 #ifdef HAVE_X_WINDOWS
8873 if (display_busy_cursor_p)
8874 start_busy_cursor ();
8875 #endif
8877 if (i == -1)
8879 Vquit_flag = Qt;
8880 QUIT;
8882 UNGCPRO;
8883 return unbind_to (count, Fvector (i, keybuf));
8886 DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
8887 "Execute CMD as an editor command.\n\
8888 CMD must be a symbol that satisfies the `commandp' predicate.\n\
8889 Optional second arg RECORD-FLAG non-nil\n\
8890 means unconditionally put this command in `command-history'.\n\
8891 Otherwise, that is done only if an arg is read using the minibuffer.\n\
8892 The argument KEYS specifies the value to use instead of (this-command-keys)\n\
8893 when reading the arguments; if it is nil, (this-command-keys) is used.\n\
8894 The argument SPECIAL, if non-nil, means that this command is executing\n\
8895 a special event, so ignore the prefix argument and don't clear it.")
8896 (cmd, record_flag, keys, special)
8897 Lisp_Object cmd, record_flag, keys, special;
8899 register Lisp_Object final;
8900 register Lisp_Object tem;
8901 Lisp_Object prefixarg;
8902 struct backtrace backtrace;
8903 extern int debug_on_next_call;
8905 debug_on_next_call = 0;
8907 if (NILP (special))
8909 prefixarg = current_kboard->Vprefix_arg;
8910 Vcurrent_prefix_arg = prefixarg;
8911 current_kboard->Vprefix_arg = Qnil;
8913 else
8914 prefixarg = Qnil;
8916 if (SYMBOLP (cmd))
8918 tem = Fget (cmd, Qdisabled);
8919 if (!NILP (tem) && !NILP (Vrun_hooks))
8921 tem = Fsymbol_value (Qdisabled_command_hook);
8922 if (!NILP (tem))
8923 return call1 (Vrun_hooks, Qdisabled_command_hook);
8927 while (1)
8929 final = Findirect_function (cmd);
8931 if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
8933 struct gcpro gcpro1, gcpro2;
8935 GCPRO2 (cmd, prefixarg);
8936 do_autoload (final, cmd);
8937 UNGCPRO;
8939 else
8940 break;
8943 if (STRINGP (final) || VECTORP (final))
8945 /* If requested, place the macro in the command history. For
8946 other sorts of commands, call-interactively takes care of
8947 this. */
8948 if (!NILP (record_flag))
8950 Vcommand_history
8951 = Fcons (Fcons (Qexecute_kbd_macro,
8952 Fcons (final, Fcons (prefixarg, Qnil))),
8953 Vcommand_history);
8955 /* Don't keep command history around forever. */
8956 if (NUMBERP (Vhistory_length) && XINT (Vhistory_length) > 0)
8958 tem = Fnthcdr (Vhistory_length, Vcommand_history);
8959 if (CONSP (tem))
8960 XCDR (tem) = Qnil;
8964 return Fexecute_kbd_macro (final, prefixarg);
8967 if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
8969 backtrace.next = backtrace_list;
8970 backtrace_list = &backtrace;
8971 backtrace.function = &Qcall_interactively;
8972 backtrace.args = &cmd;
8973 backtrace.nargs = 1;
8974 backtrace.evalargs = 0;
8976 tem = Fcall_interactively (cmd, record_flag, keys);
8978 backtrace_list = backtrace.next;
8979 return tem;
8981 return Qnil;
8984 DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
8985 1, 1, "P",
8986 "Read function name, then read its arguments and call it.")
8987 (prefixarg)
8988 Lisp_Object prefixarg;
8990 Lisp_Object function;
8991 char buf[40];
8992 Lisp_Object saved_keys;
8993 Lisp_Object bindings, value;
8994 struct gcpro gcpro1, gcpro2;
8996 saved_keys = Fvector (this_command_key_count,
8997 XVECTOR (this_command_keys)->contents);
8998 buf[0] = 0;
8999 GCPRO2 (saved_keys, prefixarg);
9001 if (EQ (prefixarg, Qminus))
9002 strcpy (buf, "- ");
9003 else if (CONSP (prefixarg) && XINT (XCAR (prefixarg)) == 4)
9004 strcpy (buf, "C-u ");
9005 else if (CONSP (prefixarg) && INTEGERP (XCAR (prefixarg)))
9007 if (sizeof (int) == sizeof (EMACS_INT))
9008 sprintf (buf, "%d ", XINT (XCAR (prefixarg)));
9009 else if (sizeof (long) == sizeof (EMACS_INT))
9010 sprintf (buf, "%ld ", (long) XINT (XCAR (prefixarg)));
9011 else
9012 abort ();
9014 else if (INTEGERP (prefixarg))
9016 if (sizeof (int) == sizeof (EMACS_INT))
9017 sprintf (buf, "%d ", XINT (prefixarg));
9018 else if (sizeof (long) == sizeof (EMACS_INT))
9019 sprintf (buf, "%ld ", (long) XINT (prefixarg));
9020 else
9021 abort ();
9024 /* This isn't strictly correct if execute-extended-command
9025 is bound to anything else. Perhaps it should use
9026 this_command_keys? */
9027 strcat (buf, "M-x ");
9029 /* Prompt with buf, and then read a string, completing from and
9030 restricting to the set of all defined commands. Don't provide
9031 any initial input. Save the command read on the extended-command
9032 history list. */
9033 function = Fcompleting_read (build_string (buf),
9034 Vobarray, Qcommandp,
9035 Qt, Qnil, Qextended_command_history, Qnil,
9036 Qnil);
9038 if (STRINGP (function) && XSTRING (function)->size == 0)
9039 error ("No command name given");
9041 /* Set this_command_keys to the concatenation of saved_keys and
9042 function, followed by a RET. */
9044 struct Lisp_String *str;
9045 Lisp_Object *keys;
9046 int i;
9048 this_command_key_count = 0;
9049 this_single_command_key_start = 0;
9051 keys = XVECTOR (saved_keys)->contents;
9052 for (i = 0; i < XVECTOR (saved_keys)->size; i++)
9053 add_command_key (keys[i]);
9055 str = XSTRING (function);
9056 for (i = 0; i < str->size; i++)
9057 add_command_key (Faref (function, make_number (i)));
9059 add_command_key (make_number ('\015'));
9062 UNGCPRO;
9064 function = Fintern (function, Qnil);
9065 current_kboard->Vprefix_arg = prefixarg;
9066 Vthis_command = function;
9067 real_this_command = function;
9069 /* If enabled, show which key runs this command. */
9070 if (!NILP (Vsuggest_key_bindings)
9071 && NILP (Vexecuting_macro)
9072 && SYMBOLP (function))
9073 bindings = Fwhere_is_internal (function, Voverriding_local_map,
9074 Qt, Qnil);
9075 else
9076 bindings = Qnil;
9078 value = Qnil;
9079 GCPRO2 (bindings, value);
9080 value = Fcommand_execute (function, Qt, Qnil, Qnil);
9082 /* If the command has a key binding, print it now. */
9083 if (!NILP (bindings)
9084 && ! (VECTORP (bindings) && EQ (Faref (bindings, make_number (0)),
9085 Qmouse_movement)))
9087 /* But first wait, and skip the message if there is input. */
9088 int delay_time;
9089 if (!NILP (echo_area_buffer[0]))
9090 /* This command displayed something in the echo area;
9091 so wait a few seconds, then display our suggestion message. */
9092 delay_time = (NUMBERP (Vsuggest_key_bindings)
9093 ? XINT (Vsuggest_key_bindings) : 2);
9094 else
9095 /* This command left the echo area empty,
9096 so display our message immediately. */
9097 delay_time = 0;
9099 if (!NILP (Fsit_for (make_number (delay_time), Qnil, Qnil))
9100 && ! CONSP (Vunread_command_events))
9102 Lisp_Object binding;
9103 char *newmessage;
9104 int message_p = push_message ();
9106 binding = Fkey_description (bindings);
9108 newmessage
9109 = (char *) alloca (XSYMBOL (function)->name->size
9110 + STRING_BYTES (XSTRING (binding))
9111 + 100);
9112 sprintf (newmessage, "You can run the command `%s' with %s",
9113 XSYMBOL (function)->name->data,
9114 XSTRING (binding)->data);
9115 message2_nolog (newmessage,
9116 strlen (newmessage),
9117 STRING_MULTIBYTE (binding));
9118 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings)
9119 ? Vsuggest_key_bindings : make_number (2)),
9120 Qnil, Qnil))
9121 && message_p)
9122 restore_message ();
9124 pop_message ();
9128 RETURN_UNGCPRO (value);
9131 /* Find the set of keymaps now active.
9132 Store into *MAPS_P a vector holding the various maps
9133 and return the number of them. The vector was malloc'd
9134 and the caller should free it. */
9137 current_active_maps (maps_p)
9138 Lisp_Object **maps_p;
9140 Lisp_Object *tmaps, *maps;
9141 int nmaps;
9143 /* Should overriding-terminal-local-map and overriding-local-map apply? */
9144 if (!NILP (Voverriding_local_map_menu_flag))
9146 /* Yes, use them (if non-nil) as well as the global map. */
9147 maps = (Lisp_Object *) xmalloc (3 * sizeof (maps[0]));
9148 nmaps = 0;
9149 if (!NILP (current_kboard->Voverriding_terminal_local_map))
9150 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
9151 if (!NILP (Voverriding_local_map))
9152 maps[nmaps++] = Voverriding_local_map;
9154 else
9156 /* No, so use major and minor mode keymaps and keymap property. */
9157 int extra_maps = 2;
9158 Lisp_Object map = get_local_map (PT, current_buffer, keymap);
9159 if (!NILP (map))
9160 extra_maps = 3;
9161 nmaps = current_minor_maps (NULL, &tmaps);
9162 maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
9163 * sizeof (maps[0]));
9164 bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
9165 if (!NILP (map))
9166 maps[nmaps++] = get_local_map (PT, current_buffer, keymap);
9167 maps[nmaps++] = get_local_map (PT, current_buffer, local_map);
9169 maps[nmaps++] = current_global_map;
9171 *maps_p = maps;
9172 return nmaps;
9175 /* Return nonzero if input events are pending. */
9178 detect_input_pending ()
9180 if (!input_pending)
9181 get_input_pending (&input_pending, 0);
9183 return input_pending;
9186 /* Return nonzero if input events are pending, and run any pending timers. */
9189 detect_input_pending_run_timers (do_display)
9190 int do_display;
9192 int old_timers_run = timers_run;
9194 if (!input_pending)
9195 get_input_pending (&input_pending, 1);
9197 if (old_timers_run != timers_run && do_display)
9199 redisplay_preserve_echo_area ();
9200 /* The following fixes a bug when using lazy-lock with
9201 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9202 from an idle timer function. The symptom of the bug is that
9203 the cursor sometimes doesn't become visible until the next X
9204 event is processed. --gerd. */
9205 if (rif)
9206 rif->flush_display (NULL);
9209 return input_pending;
9212 /* This is called in some cases before a possible quit.
9213 It cases the next call to detect_input_pending to recompute input_pending.
9214 So calling this function unnecessarily can't do any harm. */
9216 void
9217 clear_input_pending ()
9219 input_pending = 0;
9222 /* Return nonzero if there are pending requeued events.
9223 This isn't used yet. The hope is to make wait_reading_process_input
9224 call it, and return return if it runs Lisp code that unreads something.
9225 The problem is, kbd_buffer_get_event needs to be fixed to know what
9226 to do in that case. It isn't trivial. */
9229 requeued_events_pending_p ()
9231 return (!NILP (Vunread_command_events) || unread_command_char != -1);
9235 DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
9236 "T if command input is currently available with no waiting.\n\
9237 Actually, the value is nil only if we can be sure that no input is available.")
9240 if (!NILP (Vunread_command_events) || unread_command_char != -1)
9241 return (Qt);
9243 get_input_pending (&input_pending, 1);
9244 return input_pending > 0 ? Qt : Qnil;
9247 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
9248 "Return vector of last 100 events, not counting those from keyboard macros.")
9251 Lisp_Object *keys = XVECTOR (recent_keys)->contents;
9252 Lisp_Object val;
9254 if (total_keys < NUM_RECENT_KEYS)
9255 return Fvector (total_keys, keys);
9256 else
9258 val = Fvector (NUM_RECENT_KEYS, keys);
9259 bcopy (keys + recent_keys_index,
9260 XVECTOR (val)->contents,
9261 (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
9262 bcopy (keys,
9263 XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
9264 recent_keys_index * sizeof (Lisp_Object));
9265 return val;
9269 DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
9270 "Return the key sequence that invoked this command.\n\
9271 The value is a string or a vector.")
9274 return make_event_array (this_command_key_count,
9275 XVECTOR (this_command_keys)->contents);
9278 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
9279 "Return the key sequence that invoked this command, as a vector.")
9282 return Fvector (this_command_key_count,
9283 XVECTOR (this_command_keys)->contents);
9286 DEFUN ("this-single-command-keys", Fthis_single_command_keys,
9287 Sthis_single_command_keys, 0, 0, 0,
9288 "Return the key sequence that invoked this command.\n\
9289 Unlike `this-command-keys', this function's value\n\
9290 does not include prefix arguments.\n\
9291 The value is always a vector.")
9294 return Fvector (this_command_key_count
9295 - this_single_command_key_start,
9296 (XVECTOR (this_command_keys)->contents
9297 + this_single_command_key_start));
9300 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys,
9301 Sthis_single_command_raw_keys, 0, 0, 0,
9302 "Return the raw events that were read for this command.\n\
9303 Unlike `this-single-command-keys', this function's value\n\
9304 shows the events before all translations (except for input methods).\n\
9305 The value is always a vector.")
9308 return Fvector (raw_keybuf_count,
9309 (XVECTOR (raw_keybuf)->contents));
9312 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
9313 Sreset_this_command_lengths, 0, 0, 0,
9314 "Used for complicated reasons in `universal-argument-other-key'.\n\
9316 `universal-argument-other-key' rereads the event just typed.\n\
9317 It then gets translated through `function-key-map'.\n\
9318 The translated event gets included in the echo area and in\n\
9319 the value of `this-command-keys' in addition to the raw original event.\n\
9320 That is not right.\n\
9322 Calling this function directs the translated event to replace\n\
9323 the original event, so that only one version of the event actually\n\
9324 appears in the echo area and in the value of `this-command-keys.'.")
9327 before_command_restore_flag = 1;
9328 before_command_key_count_1 = before_command_key_count;
9329 before_command_echo_length_1 = before_command_echo_length;
9330 return Qnil;
9333 DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
9334 Sclear_this_command_keys, 0, 0, 0,
9335 "Clear out the vector that `this-command-keys' returns.\n\
9336 Clear vector containing last 100 events.")
9339 int i;
9341 this_command_key_count = 0;
9343 for (i = 0; i < XVECTOR (recent_keys)->size; ++i)
9344 XVECTOR (recent_keys)->contents[i] = Qnil;
9345 total_keys = 0;
9346 recent_keys_index = 0;
9347 return Qnil;
9350 DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
9351 "Return the current depth in recursive edits.")
9354 Lisp_Object temp;
9355 XSETFASTINT (temp, command_loop_level + minibuf_level);
9356 return temp;
9359 DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
9360 "FOpen dribble file: ",
9361 "Start writing all keyboard characters to a dribble file called FILE.\n\
9362 If FILE is nil, close any open dribble file.")
9363 (file)
9364 Lisp_Object file;
9366 if (dribble)
9368 fclose (dribble);
9369 dribble = 0;
9371 if (!NILP (file))
9373 file = Fexpand_file_name (file, Qnil);
9374 dribble = fopen (XSTRING (file)->data, "w");
9375 if (dribble == 0)
9376 report_file_error ("Opening dribble", Fcons (file, Qnil));
9378 return Qnil;
9381 DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
9382 "Discard the contents of the terminal input buffer.\n\
9383 Also cancel any kbd macro being defined.")
9386 current_kboard->defining_kbd_macro = Qnil;
9387 update_mode_lines++;
9389 Vunread_command_events = Qnil;
9390 unread_command_char = -1;
9392 discard_tty_input ();
9394 kbd_fetch_ptr = kbd_store_ptr;
9395 Ffillarray (kbd_buffer_gcpro, Qnil);
9396 input_pending = 0;
9398 return Qnil;
9401 DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
9402 "Stop Emacs and return to superior process. You can resume later.\n\
9403 If `cannot-suspend' is non-nil, or if the system doesn't support job\n\
9404 control, run a subshell instead.\n\n\
9405 If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
9406 to be read as terminal input by Emacs's parent, after suspension.\n\
9408 Before suspending, run the normal hook `suspend-hook'.\n\
9409 After resumption run the normal hook `suspend-resume-hook'.\n\
9411 Some operating systems cannot stop the Emacs process and resume it later.\n\
9412 On such systems, Emacs starts a subshell instead of suspending.")
9413 (stuffstring)
9414 Lisp_Object stuffstring;
9416 int count = specpdl_ptr - specpdl;
9417 int old_height, old_width;
9418 int width, height;
9419 struct gcpro gcpro1;
9421 if (!NILP (stuffstring))
9422 CHECK_STRING (stuffstring, 0);
9424 /* Run the functions in suspend-hook. */
9425 if (!NILP (Vrun_hooks))
9426 call1 (Vrun_hooks, intern ("suspend-hook"));
9428 GCPRO1 (stuffstring);
9429 get_frame_size (&old_width, &old_height);
9430 reset_sys_modes ();
9431 /* sys_suspend can get an error if it tries to fork a subshell
9432 and the system resources aren't available for that. */
9433 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_sys_modes,
9434 Qnil);
9435 stuff_buffered_input (stuffstring);
9436 if (cannot_suspend)
9437 sys_subshell ();
9438 else
9439 sys_suspend ();
9440 unbind_to (count, Qnil);
9442 /* Check if terminal/window size has changed.
9443 Note that this is not useful when we are running directly
9444 with a window system; but suspend should be disabled in that case. */
9445 get_frame_size (&width, &height);
9446 if (width != old_width || height != old_height)
9447 change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
9449 /* Run suspend-resume-hook. */
9450 if (!NILP (Vrun_hooks))
9451 call1 (Vrun_hooks, intern ("suspend-resume-hook"));
9453 UNGCPRO;
9454 return Qnil;
9457 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
9458 Then in any case stuff anything Emacs has read ahead and not used. */
9460 void
9461 stuff_buffered_input (stuffstring)
9462 Lisp_Object stuffstring;
9464 /* stuff_char works only in BSD, versions 4.2 and up. */
9465 #ifdef BSD_SYSTEM
9466 #ifndef BSD4_1
9467 register unsigned char *p;
9469 if (STRINGP (stuffstring))
9471 register int count;
9473 p = XSTRING (stuffstring)->data;
9474 count = STRING_BYTES (XSTRING (stuffstring));
9475 while (count-- > 0)
9476 stuff_char (*p++);
9477 stuff_char ('\n');
9480 /* Anything we have read ahead, put back for the shell to read. */
9481 /* ?? What should this do when we have multiple keyboards??
9482 Should we ignore anything that was typed in at the "wrong" kboard? */
9483 for (; kbd_fetch_ptr != kbd_store_ptr; kbd_fetch_ptr++)
9485 int idx;
9487 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
9488 kbd_fetch_ptr = kbd_buffer;
9489 if (kbd_fetch_ptr->kind == ascii_keystroke)
9490 stuff_char (kbd_fetch_ptr->code);
9492 kbd_fetch_ptr->kind = no_event;
9493 idx = 2 * (kbd_fetch_ptr - kbd_buffer);
9494 ASET (kbd_buffer_gcpro, idx, Qnil);
9495 ASET (kbd_buffer_gcpro, idx + 1, Qnil);
9498 input_pending = 0;
9499 #endif
9500 #endif /* BSD_SYSTEM and not BSD4_1 */
9503 void
9504 set_waiting_for_input (time_to_clear)
9505 EMACS_TIME *time_to_clear;
9507 input_available_clear_time = time_to_clear;
9509 /* Tell interrupt_signal to throw back to read_char, */
9510 waiting_for_input = 1;
9512 /* If interrupt_signal was called before and buffered a C-g,
9513 make it run again now, to avoid timing error. */
9514 if (!NILP (Vquit_flag))
9515 quit_throw_to_read_char ();
9518 void
9519 clear_waiting_for_input ()
9521 /* Tell interrupt_signal not to throw back to read_char, */
9522 waiting_for_input = 0;
9523 input_available_clear_time = 0;
9526 /* This routine is called at interrupt level in response to C-G.
9528 If interrupt_input, this is the handler for SIGINT. Otherwise, it
9529 is called from kbd_buffer_store_event, in handling SIGIO or
9530 SIGTINT.
9532 If `waiting_for_input' is non zero, then unless `echoing' is
9533 nonzero, immediately throw back to read_char.
9535 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
9536 eval to throw, when it gets a chance. If quit-flag is already
9537 non-nil, it stops the job right away. */
9539 SIGTYPE
9540 interrupt_signal (signalnum) /* If we don't have an argument, */
9541 int signalnum; /* some compilers complain in signal calls. */
9543 char c;
9544 /* Must preserve main program's value of errno. */
9545 int old_errno = errno;
9546 struct frame *sf = SELECTED_FRAME ();
9548 #if defined (USG) && !defined (POSIX_SIGNALS)
9549 if (!read_socket_hook && NILP (Vwindow_system))
9551 /* USG systems forget handlers when they are used;
9552 must reestablish each time */
9553 signal (SIGINT, interrupt_signal);
9554 signal (SIGQUIT, interrupt_signal);
9556 #endif /* USG */
9558 cancel_echoing ();
9560 if (!NILP (Vquit_flag)
9561 && (FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf)))
9563 /* If SIGINT isn't blocked, don't let us be interrupted by
9564 another SIGINT, it might be harmful due to non-reentrancy
9565 in I/O functions. */
9566 sigblock (sigmask (SIGINT));
9568 fflush (stdout);
9569 reset_sys_modes ();
9571 #ifdef SIGTSTP /* Support possible in later USG versions */
9573 * On systems which can suspend the current process and return to the original
9574 * shell, this command causes the user to end up back at the shell.
9575 * The "Auto-save" and "Abort" questions are not asked until
9576 * the user elects to return to emacs, at which point he can save the current
9577 * job and either dump core or continue.
9579 sys_suspend ();
9580 #else
9581 #ifdef VMS
9582 if (sys_suspend () == -1)
9584 printf ("Not running as a subprocess;\n");
9585 printf ("you can continue or abort.\n");
9587 #else /* not VMS */
9588 /* Perhaps should really fork an inferior shell?
9589 But that would not provide any way to get back
9590 to the original shell, ever. */
9591 printf ("No support for stopping a process on this operating system;\n");
9592 printf ("you can continue or abort.\n");
9593 #endif /* not VMS */
9594 #endif /* not SIGTSTP */
9595 #ifdef MSDOS
9596 /* We must remain inside the screen area when the internal terminal
9597 is used. Note that [Enter] is not echoed by dos. */
9598 cursor_to (0, 0);
9599 #endif
9600 /* It doesn't work to autosave while GC is in progress;
9601 the code used for auto-saving doesn't cope with the mark bit. */
9602 if (!gc_in_progress)
9604 printf ("Auto-save? (y or n) ");
9605 fflush (stdout);
9606 if (((c = getchar ()) & ~040) == 'Y')
9608 Fdo_auto_save (Qt, Qnil);
9609 #ifdef MSDOS
9610 printf ("\r\nAuto-save done");
9611 #else /* not MSDOS */
9612 printf ("Auto-save done\n");
9613 #endif /* not MSDOS */
9615 while (c != '\n') c = getchar ();
9617 else
9619 /* During GC, it must be safe to reenable quitting again. */
9620 Vinhibit_quit = Qnil;
9621 #ifdef MSDOS
9622 printf ("\r\n");
9623 #endif /* not MSDOS */
9624 printf ("Garbage collection in progress; cannot auto-save now\r\n");
9625 printf ("but will instead do a real quit after garbage collection ends\r\n");
9626 fflush (stdout);
9629 #ifdef MSDOS
9630 printf ("\r\nAbort? (y or n) ");
9631 #else /* not MSDOS */
9632 #ifdef VMS
9633 printf ("Abort (and enter debugger)? (y or n) ");
9634 #else /* not VMS */
9635 printf ("Abort (and dump core)? (y or n) ");
9636 #endif /* not VMS */
9637 #endif /* not MSDOS */
9638 fflush (stdout);
9639 if (((c = getchar ()) & ~040) == 'Y')
9640 abort ();
9641 while (c != '\n') c = getchar ();
9642 #ifdef MSDOS
9643 printf ("\r\nContinuing...\r\n");
9644 #else /* not MSDOS */
9645 printf ("Continuing...\n");
9646 #endif /* not MSDOS */
9647 fflush (stdout);
9648 init_sys_modes ();
9649 sigfree ();
9651 else
9653 /* If executing a function that wants to be interrupted out of
9654 and the user has not deferred quitting by binding `inhibit-quit'
9655 then quit right away. */
9656 if (immediate_quit && NILP (Vinhibit_quit))
9658 struct gl_state_s saved;
9659 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
9661 immediate_quit = 0;
9662 sigfree ();
9663 saved = gl_state;
9664 GCPRO4 (saved.object, saved.global_code,
9665 saved.current_syntax_table, saved.old_prop);
9666 Fsignal (Qquit, Qnil);
9667 gl_state = saved;
9668 UNGCPRO;
9670 else
9671 /* Else request quit when it's safe */
9672 Vquit_flag = Qt;
9675 if (waiting_for_input && !echoing)
9676 quit_throw_to_read_char ();
9678 errno = old_errno;
9681 /* Handle a C-g by making read_char return C-g. */
9683 void
9684 quit_throw_to_read_char ()
9686 sigfree ();
9687 /* Prevent another signal from doing this before we finish. */
9688 clear_waiting_for_input ();
9689 input_pending = 0;
9691 Vunread_command_events = Qnil;
9692 unread_command_char = -1;
9694 #if 0 /* Currently, sit_for is called from read_char without turning
9695 off polling. And that can call set_waiting_for_input.
9696 It seems to be harmless. */
9697 #ifdef POLL_FOR_INPUT
9698 /* May be > 1 if in recursive minibuffer. */
9699 if (poll_suppress_count == 0)
9700 abort ();
9701 #endif
9702 #endif
9703 if (FRAMEP (internal_last_event_frame)
9704 && !EQ (internal_last_event_frame, selected_frame))
9705 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame),
9706 Qnil, 0);
9708 _longjmp (getcjmp, 1);
9711 DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
9712 "Set mode of reading keyboard input.\n\
9713 First arg INTERRUPT non-nil means use input interrupts;\n\
9714 nil means use CBREAK mode.\n\
9715 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal\n\
9716 (no effect except in CBREAK mode).\n\
9717 Third arg META t means accept 8-bit input (for a Meta key).\n\
9718 META nil means ignore the top bit, on the assumption it is parity.\n\
9719 Otherwise, accept 8-bit input and don't use the top bit for Meta.\n\
9720 Optional fourth arg QUIT if non-nil specifies character to use for quitting.\n\
9721 See also `current-input-mode'.")
9722 (interrupt, flow, meta, quit)
9723 Lisp_Object interrupt, flow, meta, quit;
9725 if (!NILP (quit)
9726 && (!INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400))
9727 error ("set-input-mode: QUIT must be an ASCII character");
9729 #ifdef POLL_FOR_INPUT
9730 stop_polling ();
9731 #endif
9733 #ifndef DOS_NT
9734 /* this causes startup screen to be restored and messes with the mouse */
9735 reset_sys_modes ();
9736 #endif
9738 #ifdef SIGIO
9739 /* Note SIGIO has been undef'd if FIONREAD is missing. */
9740 if (read_socket_hook)
9742 /* When using X, don't give the user a real choice,
9743 because we haven't implemented the mechanisms to support it. */
9744 #ifdef NO_SOCK_SIGIO
9745 interrupt_input = 0;
9746 #else /* not NO_SOCK_SIGIO */
9747 interrupt_input = 1;
9748 #endif /* NO_SOCK_SIGIO */
9750 else
9751 interrupt_input = !NILP (interrupt);
9752 #else /* not SIGIO */
9753 interrupt_input = 0;
9754 #endif /* not SIGIO */
9756 /* Our VMS input only works by interrupts, as of now. */
9757 #ifdef VMS
9758 interrupt_input = 1;
9759 #endif
9761 flow_control = !NILP (flow);
9762 if (NILP (meta))
9763 meta_key = 0;
9764 else if (EQ (meta, Qt))
9765 meta_key = 1;
9766 else
9767 meta_key = 2;
9768 if (!NILP (quit))
9769 /* Don't let this value be out of range. */
9770 quit_char = XINT (quit) & (meta_key ? 0377 : 0177);
9772 #ifndef DOS_NT
9773 init_sys_modes ();
9774 #endif
9776 #ifdef POLL_FOR_INPUT
9777 poll_suppress_count = 1;
9778 start_polling ();
9779 #endif
9780 return Qnil;
9783 DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
9784 "Return information about the way Emacs currently reads keyboard input.\n\
9785 The value is a list of the form (INTERRUPT FLOW META QUIT), where\n\
9786 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if\n\
9787 nil, Emacs is using CBREAK mode.\n\
9788 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the\n\
9789 terminal; this does not apply if Emacs uses interrupt-driven input.\n\
9790 META is t if accepting 8-bit input with 8th bit as Meta flag.\n\
9791 META nil means ignoring the top bit, on the assumption it is parity.\n\
9792 META is neither t nor nil if accepting 8-bit input and using\n\
9793 all 8 bits as the character code.\n\
9794 QUIT is the character Emacs currently uses to quit.\n\
9795 The elements of this list correspond to the arguments of\n\
9796 `set-input-mode'.")
9799 Lisp_Object val[4];
9801 val[0] = interrupt_input ? Qt : Qnil;
9802 val[1] = flow_control ? Qt : Qnil;
9803 val[2] = meta_key == 2 ? make_number (0) : meta_key == 1 ? Qt : Qnil;
9804 XSETFASTINT (val[3], quit_char);
9806 return Flist (sizeof (val) / sizeof (val[0]), val);
9811 * Set up a new kboard object with reasonable initial values.
9813 void
9814 init_kboard (kb)
9815 KBOARD *kb;
9817 kb->Voverriding_terminal_local_map = Qnil;
9818 kb->Vlast_command = Qnil;
9819 kb->Vreal_last_command = Qnil;
9820 kb->Vprefix_arg = Qnil;
9821 kb->Vlast_prefix_arg = Qnil;
9822 kb->kbd_queue = Qnil;
9823 kb->kbd_queue_has_data = 0;
9824 kb->immediate_echo = 0;
9825 kb->echoptr = kb->echobuf;
9826 kb->echo_after_prompt = -1;
9827 kb->kbd_macro_buffer = 0;
9828 kb->kbd_macro_bufsize = 0;
9829 kb->defining_kbd_macro = Qnil;
9830 kb->Vlast_kbd_macro = Qnil;
9831 kb->reference_count = 0;
9832 kb->Vsystem_key_alist = Qnil;
9833 kb->system_key_syms = Qnil;
9834 kb->Vdefault_minibuffer_frame = Qnil;
9838 * Destroy the contents of a kboard object, but not the object itself.
9839 * We use this just before deleting it, or if we're going to initialize
9840 * it a second time.
9842 static void
9843 wipe_kboard (kb)
9844 KBOARD *kb;
9846 if (kb->kbd_macro_buffer)
9847 xfree (kb->kbd_macro_buffer);
9850 #ifdef MULTI_KBOARD
9851 void
9852 delete_kboard (kb)
9853 KBOARD *kb;
9855 KBOARD **kbp;
9856 for (kbp = &all_kboards; *kbp != kb; kbp = &(*kbp)->next_kboard)
9857 if (*kbp == NULL)
9858 abort ();
9859 *kbp = kb->next_kboard;
9860 wipe_kboard (kb);
9861 xfree (kb);
9863 #endif
9865 void
9866 init_keyboard ()
9868 /* This is correct before outermost invocation of the editor loop */
9869 command_loop_level = -1;
9870 immediate_quit = 0;
9871 quit_char = Ctl ('g');
9872 Vunread_command_events = Qnil;
9873 unread_command_char = -1;
9874 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
9875 total_keys = 0;
9876 recent_keys_index = 0;
9877 kbd_fetch_ptr = kbd_buffer;
9878 kbd_store_ptr = kbd_buffer;
9879 kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
9880 #ifdef HAVE_MOUSE
9881 do_mouse_tracking = Qnil;
9882 #endif
9883 input_pending = 0;
9885 /* This means that command_loop_1 won't try to select anything the first
9886 time through. */
9887 internal_last_event_frame = Qnil;
9888 Vlast_event_frame = internal_last_event_frame;
9890 #ifdef MULTI_KBOARD
9891 current_kboard = initial_kboard;
9892 #endif
9893 wipe_kboard (current_kboard);
9894 init_kboard (current_kboard);
9896 if (initialized)
9897 Ffillarray (kbd_buffer_gcpro, Qnil);
9899 kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
9900 if (!noninteractive && !read_socket_hook && NILP (Vwindow_system))
9902 signal (SIGINT, interrupt_signal);
9903 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
9904 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
9905 SIGQUIT and we can't tell which one it will give us. */
9906 signal (SIGQUIT, interrupt_signal);
9907 #endif /* HAVE_TERMIO */
9909 /* Note SIGIO has been undef'd if FIONREAD is missing. */
9910 #ifdef SIGIO
9911 if (!noninteractive)
9912 signal (SIGIO, input_available_signal);
9913 #endif /* SIGIO */
9915 /* Use interrupt input by default, if it works and noninterrupt input
9916 has deficiencies. */
9918 #ifdef INTERRUPT_INPUT
9919 interrupt_input = 1;
9920 #else
9921 interrupt_input = 0;
9922 #endif
9924 /* Our VMS input only works by interrupts, as of now. */
9925 #ifdef VMS
9926 interrupt_input = 1;
9927 #endif
9929 sigfree ();
9930 dribble = 0;
9932 if (keyboard_init_hook)
9933 (*keyboard_init_hook) ();
9935 #ifdef POLL_FOR_INPUT
9936 poll_suppress_count = 1;
9937 start_polling ();
9938 #endif
9941 /* This type's only use is in syms_of_keyboard, to initialize the
9942 event header symbols and put properties on them. */
9943 struct event_head {
9944 Lisp_Object *var;
9945 char *name;
9946 Lisp_Object *kind;
9949 struct event_head head_table[] = {
9950 &Qmouse_movement, "mouse-movement", &Qmouse_movement,
9951 &Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement,
9952 &Qswitch_frame, "switch-frame", &Qswitch_frame,
9953 &Qdelete_frame, "delete-frame", &Qdelete_frame,
9954 &Qiconify_frame, "iconify-frame", &Qiconify_frame,
9955 &Qmake_frame_visible, "make-frame-visible", &Qmake_frame_visible,
9958 void
9959 syms_of_keyboard ()
9961 Vlispy_mouse_stem = build_string ("mouse");
9962 staticpro (&Vlispy_mouse_stem);
9964 /* Tool-bars. */
9965 QCimage = intern (":image");
9966 staticpro (&QCimage);
9968 staticpro (&Qhelp_echo);
9969 Qhelp_echo = intern ("help-echo");
9971 staticpro (&item_properties);
9972 item_properties = Qnil;
9974 staticpro (&tool_bar_item_properties);
9975 tool_bar_item_properties = Qnil;
9976 staticpro (&tool_bar_items_vector);
9977 tool_bar_items_vector = Qnil;
9979 staticpro (&real_this_command);
9980 real_this_command = Qnil;
9982 Qtimer_event_handler = intern ("timer-event-handler");
9983 staticpro (&Qtimer_event_handler);
9985 Qdisabled_command_hook = intern ("disabled-command-hook");
9986 staticpro (&Qdisabled_command_hook);
9988 Qself_insert_command = intern ("self-insert-command");
9989 staticpro (&Qself_insert_command);
9991 Qforward_char = intern ("forward-char");
9992 staticpro (&Qforward_char);
9994 Qbackward_char = intern ("backward-char");
9995 staticpro (&Qbackward_char);
9997 Qdisabled = intern ("disabled");
9998 staticpro (&Qdisabled);
10000 Qundefined = intern ("undefined");
10001 staticpro (&Qundefined);
10003 Qpre_command_hook = intern ("pre-command-hook");
10004 staticpro (&Qpre_command_hook);
10006 Qpost_command_hook = intern ("post-command-hook");
10007 staticpro (&Qpost_command_hook);
10009 Qpost_command_idle_hook = intern ("post-command-idle-hook");
10010 staticpro (&Qpost_command_idle_hook);
10012 Qdeferred_action_function = intern ("deferred-action-function");
10013 staticpro (&Qdeferred_action_function);
10015 Qcommand_hook_internal = intern ("command-hook-internal");
10016 staticpro (&Qcommand_hook_internal);
10018 Qfunction_key = intern ("function-key");
10019 staticpro (&Qfunction_key);
10020 Qmouse_click = intern ("mouse-click");
10021 staticpro (&Qmouse_click);
10022 #ifdef WINDOWSNT
10023 Qmouse_wheel = intern ("mouse-wheel");
10024 staticpro (&Qmouse_wheel);
10025 Qlanguage_change = intern ("language-change");
10026 staticpro (&Qlanguage_change);
10027 #endif
10028 Qdrag_n_drop = intern ("drag-n-drop");
10029 staticpro (&Qdrag_n_drop);
10031 Qusr1_signal = intern ("usr1-signal");
10032 staticpro (&Qusr1_signal);
10033 Qusr2_signal = intern ("usr2-signal");
10034 staticpro (&Qusr2_signal);
10036 Qmenu_enable = intern ("menu-enable");
10037 staticpro (&Qmenu_enable);
10038 Qmenu_alias = intern ("menu-alias");
10039 staticpro (&Qmenu_alias);
10040 QCenable = intern (":enable");
10041 staticpro (&QCenable);
10042 QCvisible = intern (":visible");
10043 staticpro (&QCvisible);
10044 QChelp = intern (":help");
10045 staticpro (&QChelp);
10046 QCfilter = intern (":filter");
10047 staticpro (&QCfilter);
10048 QCbutton = intern (":button");
10049 staticpro (&QCbutton);
10050 QCkeys = intern (":keys");
10051 staticpro (&QCkeys);
10052 QCkey_sequence = intern (":key-sequence");
10053 staticpro (&QCkey_sequence);
10054 QCtoggle = intern (":toggle");
10055 staticpro (&QCtoggle);
10056 QCradio = intern (":radio");
10057 staticpro (&QCradio);
10059 Qmode_line = intern ("mode-line");
10060 staticpro (&Qmode_line);
10061 Qvertical_line = intern ("vertical-line");
10062 staticpro (&Qvertical_line);
10063 Qvertical_scroll_bar = intern ("vertical-scroll-bar");
10064 staticpro (&Qvertical_scroll_bar);
10065 Qmenu_bar = intern ("menu-bar");
10066 staticpro (&Qmenu_bar);
10068 Qabove_handle = intern ("above-handle");
10069 staticpro (&Qabove_handle);
10070 Qhandle = intern ("handle");
10071 staticpro (&Qhandle);
10072 Qbelow_handle = intern ("below-handle");
10073 staticpro (&Qbelow_handle);
10074 Qup = intern ("up");
10075 staticpro (&Qup);
10076 Qdown = intern ("down");
10077 staticpro (&Qdown);
10078 Qtop = intern ("top");
10079 staticpro (&Qtop);
10080 Qbottom = intern ("bottom");
10081 staticpro (&Qbottom);
10082 Qend_scroll = intern ("end-scroll");
10083 staticpro (&Qend_scroll);
10084 Qratio = intern ("ratio");
10085 staticpro (&Qratio);
10087 Qevent_kind = intern ("event-kind");
10088 staticpro (&Qevent_kind);
10089 Qevent_symbol_elements = intern ("event-symbol-elements");
10090 staticpro (&Qevent_symbol_elements);
10091 Qevent_symbol_element_mask = intern ("event-symbol-element-mask");
10092 staticpro (&Qevent_symbol_element_mask);
10093 Qmodifier_cache = intern ("modifier-cache");
10094 staticpro (&Qmodifier_cache);
10096 Qrecompute_lucid_menubar = intern ("recompute-lucid-menubar");
10097 staticpro (&Qrecompute_lucid_menubar);
10098 Qactivate_menubar_hook = intern ("activate-menubar-hook");
10099 staticpro (&Qactivate_menubar_hook);
10101 Qpolling_period = intern ("polling-period");
10102 staticpro (&Qpolling_period);
10104 Qinput_method_function = intern ("input-method-function");
10105 staticpro (&Qinput_method_function);
10107 Qinput_method_exit_on_first_char = intern ("input-method-exit-on-first-char");
10108 staticpro (&Qinput_method_exit_on_first_char);
10109 Qinput_method_use_echo_area = intern ("input-method-use-echo-area");
10110 staticpro (&Qinput_method_use_echo_area);
10112 Fset (Qinput_method_exit_on_first_char, Qnil);
10113 Fset (Qinput_method_use_echo_area, Qnil);
10115 last_point_position_buffer = Qnil;
10118 struct event_head *p;
10120 for (p = head_table;
10121 p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
10122 p++)
10124 *p->var = intern (p->name);
10125 staticpro (p->var);
10126 Fput (*p->var, Qevent_kind, *p->kind);
10127 Fput (*p->var, Qevent_symbol_elements, Fcons (*p->var, Qnil));
10131 button_down_location = Fmake_vector (make_number (1), Qnil);
10132 staticpro (&button_down_location);
10133 mouse_syms = Fmake_vector (make_number (1), Qnil);
10134 staticpro (&mouse_syms);
10137 int i;
10138 int len = sizeof (modifier_names) / sizeof (modifier_names[0]);
10140 modifier_symbols = Fmake_vector (make_number (len), Qnil);
10141 for (i = 0; i < len; i++)
10142 if (modifier_names[i])
10143 XVECTOR (modifier_symbols)->contents[i] = intern (modifier_names[i]);
10144 staticpro (&modifier_symbols);
10147 recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
10148 staticpro (&recent_keys);
10150 this_command_keys = Fmake_vector (make_number (40), Qnil);
10151 staticpro (&this_command_keys);
10153 raw_keybuf = Fmake_vector (make_number (30), Qnil);
10154 staticpro (&raw_keybuf);
10156 Qextended_command_history = intern ("extended-command-history");
10157 Fset (Qextended_command_history, Qnil);
10158 staticpro (&Qextended_command_history);
10160 kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
10161 staticpro (&kbd_buffer_gcpro);
10163 accent_key_syms = Qnil;
10164 staticpro (&accent_key_syms);
10166 func_key_syms = Qnil;
10167 staticpro (&func_key_syms);
10169 #ifdef WINDOWSNT
10170 mouse_wheel_syms = Qnil;
10171 staticpro (&mouse_wheel_syms);
10173 drag_n_drop_syms = Qnil;
10174 staticpro (&drag_n_drop_syms);
10175 #endif
10177 unread_switch_frame = Qnil;
10178 staticpro (&unread_switch_frame);
10180 internal_last_event_frame = Qnil;
10181 staticpro (&internal_last_event_frame);
10183 read_key_sequence_cmd = Qnil;
10184 staticpro (&read_key_sequence_cmd);
10186 menu_bar_one_keymap_changed_items = Qnil;
10187 staticpro (&menu_bar_one_keymap_changed_items);
10189 defsubr (&Sevent_convert_list);
10190 defsubr (&Sread_key_sequence);
10191 defsubr (&Sread_key_sequence_vector);
10192 defsubr (&Srecursive_edit);
10193 #ifdef HAVE_MOUSE
10194 defsubr (&Strack_mouse);
10195 #endif
10196 defsubr (&Sinput_pending_p);
10197 defsubr (&Scommand_execute);
10198 defsubr (&Srecent_keys);
10199 defsubr (&Sthis_command_keys);
10200 defsubr (&Sthis_command_keys_vector);
10201 defsubr (&Sthis_single_command_keys);
10202 defsubr (&Sthis_single_command_raw_keys);
10203 defsubr (&Sreset_this_command_lengths);
10204 defsubr (&Sclear_this_command_keys);
10205 defsubr (&Ssuspend_emacs);
10206 defsubr (&Sabort_recursive_edit);
10207 defsubr (&Sexit_recursive_edit);
10208 defsubr (&Srecursion_depth);
10209 defsubr (&Stop_level);
10210 defsubr (&Sdiscard_input);
10211 defsubr (&Sopen_dribble_file);
10212 defsubr (&Sset_input_mode);
10213 defsubr (&Scurrent_input_mode);
10214 defsubr (&Sexecute_extended_command);
10216 DEFVAR_LISP ("last-command-char", &last_command_char,
10217 "Last input event that was part of a command.");
10219 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char,
10220 "Last input event that was part of a command.");
10222 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
10223 "Last input event in a command, except for mouse menu events.\n\
10224 Mouse menus give back keys that don't look like mouse events;\n\
10225 this variable holds the actual mouse event that led to the menu,\n\
10226 so that you can determine whether the command was run by mouse or not.");
10228 DEFVAR_LISP ("last-input-char", &last_input_char,
10229 "Last input event.");
10231 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char,
10232 "Last input event.");
10234 DEFVAR_LISP ("unread-command-events", &Vunread_command_events,
10235 "List of events to be read as the command input.\n\
10236 These events are processed first, before actual keyboard input.");
10237 Vunread_command_events = Qnil;
10239 DEFVAR_INT ("unread-command-char", &unread_command_char,
10240 "If not -1, an object to be read as next command input event.");
10242 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events,
10243 "List of events to be processed as input by input methods.\n\
10244 These events are processed after `unread-command-events', but\n\
10245 before actual keyboard input.");
10246 Vunread_post_input_method_events = Qnil;
10248 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events,
10249 "List of events to be processed as input by input methods.\n\
10250 These events are processed after `unread-command-events', but\n\
10251 before actual keyboard input.");
10252 Vunread_input_method_events = Qnil;
10254 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char,
10255 "Meta-prefix character code.\n\
10256 Meta-foo as command input turns into this character followed by foo.");
10257 XSETINT (meta_prefix_char, 033);
10259 DEFVAR_KBOARD ("last-command", Vlast_command,
10260 "The last command executed.\n\
10261 Normally a symbol with a function definition, but can be whatever was found\n\
10262 in the keymap, or whatever the variable `this-command' was set to by that\n\
10263 command.\n\
10265 The value `mode-exit' is special; it means that the previous command\n\
10266 read an event that told it to exit, and it did so and unread that event.\n\
10267 In other words, the present command is the event that made the previous\n\
10268 command exit.\n\
10270 The value `kill-region' is special; it means that the previous command\n\
10271 was a kill command.");
10273 DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
10274 "Same as `last-command', but never altered by Lisp code.");
10276 DEFVAR_LISP ("this-command", &Vthis_command,
10277 "The command now being executed.\n\
10278 The command can set this variable; whatever is put here\n\
10279 will be in `last-command' during the following command.");
10280 Vthis_command = Qnil;
10282 DEFVAR_INT ("auto-save-interval", &auto_save_interval,
10283 "*Number of input events between auto-saves.\n\
10284 Zero means disable autosaving due to number of characters typed.");
10285 auto_save_interval = 300;
10287 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout,
10288 "*Number of seconds idle time before auto-save.\n\
10289 Zero or nil means disable auto-saving due to idleness.\n\
10290 After auto-saving due to this many seconds of idle time,\n\
10291 Emacs also does a garbage collection if that seems to be warranted.");
10292 XSETFASTINT (Vauto_save_timeout, 30);
10294 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes,
10295 "*Nonzero means echo unfinished commands after this many seconds of pause.\n\
10296 The value may be integer or floating point.");
10297 Vecho_keystrokes = make_number (1);
10299 DEFVAR_INT ("polling-period", &polling_period,
10300 "*Interval between polling for input during Lisp execution.\n\
10301 The reason for polling is to make C-g work to stop a running program.\n\
10302 Polling is needed only when using X windows and SIGIO does not work.\n\
10303 Polling is automatically disabled in all other cases.");
10304 polling_period = 2;
10306 DEFVAR_LISP ("double-click-time", &Vdouble_click_time,
10307 "*Maximum time between mouse clicks to make a double-click.\n\
10308 Measured in milliseconds. nil means disable double-click recognition;\n\
10309 t means double-clicks have no time limit and are detected\n\
10310 by position only.");
10311 Vdouble_click_time = make_number (500);
10313 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus,
10314 "*Non-nil means inhibit local map menu bar menus.");
10315 inhibit_local_menu_bar_menus = 0;
10317 DEFVAR_INT ("num-input-keys", &num_input_keys,
10318 "Number of complete key sequences read as input so far.\n\
10319 This includes key sequences read from keyboard macros.\n\
10320 The number is effectively the number of interactive command invocations.");
10321 num_input_keys = 0;
10323 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events,
10324 "Number of input events read from the keyboard so far.\n\
10325 This does not include events generated by keyboard macros.");
10326 num_nonmacro_input_events = 0;
10328 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
10329 "The frame in which the most recently read event occurred.\n\
10330 If the last event came from a keyboard macro, this is set to `macro'.");
10331 Vlast_event_frame = Qnil;
10333 /* This variable is set up in sysdep.c. */
10334 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char,
10335 "The ERASE character as set by the user with stty.");
10337 DEFVAR_LISP ("help-char", &Vhelp_char,
10338 "Character to recognize as meaning Help.\n\
10339 When it is read, do `(eval help-form)', and display result if it's a string.\n\
10340 If the value of `help-form' is nil, this char can be read normally.");
10341 XSETINT (Vhelp_char, Ctl ('H'));
10343 DEFVAR_LISP ("help-event-list", &Vhelp_event_list,
10344 "List of input events to recognize as meaning Help.\n\
10345 These work just like the value of `help-char' (see that).");
10346 Vhelp_event_list = Qnil;
10348 DEFVAR_LISP ("help-form", &Vhelp_form,
10349 "Form to execute when character `help-char' is read.\n\
10350 If the form returns a string, that string is displayed.\n\
10351 If `help-form' is nil, the help char is not recognized.");
10352 Vhelp_form = Qnil;
10354 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command,
10355 "Command to run when `help-char' character follows a prefix key.\n\
10356 This command is used only when there is no actual binding\n\
10357 for that character after that prefix key.");
10358 Vprefix_help_command = Qnil;
10360 DEFVAR_LISP ("top-level", &Vtop_level,
10361 "Form to evaluate when Emacs starts up.\n\
10362 Useful to set before you dump a modified Emacs.");
10363 Vtop_level = Qnil;
10365 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table,
10366 "Translate table for keyboard input, or nil.\n\
10367 Each character is looked up in this string and the contents used instead.\n\
10368 The value may be a string, a vector, or a char-table.\n\
10369 If it is a string or vector of length N,\n\
10370 character codes N and up are untranslated.\n\
10371 In a vector or a char-table, an element which is nil means \"no translation\".");
10372 Vkeyboard_translate_table = Qnil;
10374 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
10375 "Non-nil means to always spawn a subshell instead of suspending.\n\
10376 \(Even if the operating system has support for stopping a process.\)");
10377 cannot_suspend = 0;
10379 DEFVAR_BOOL ("menu-prompting", &menu_prompting,
10380 "Non-nil means prompt with menus when appropriate.\n\
10381 This is done when reading from a keymap that has a prompt string,\n\
10382 for elements that have prompt strings.\n\
10383 The menu is displayed on the screen\n\
10384 if X menus were enabled at configuration\n\
10385 time and the previous event was a mouse click prefix key.\n\
10386 Otherwise, menu prompting uses the echo area.");
10387 menu_prompting = 1;
10389 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,
10390 "Character to see next line of menu prompt.\n\
10391 Type this character while in a menu prompt to rotate around the lines of it.");
10392 XSETINT (menu_prompt_more_char, ' ');
10394 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers,
10395 "A mask of additional modifier keys to use with every keyboard character.\n\
10396 Emacs applies the modifiers of the character stored here to each keyboard\n\
10397 character it reads. For example, after evaluating the expression\n\
10398 (setq extra-keyboard-modifiers ?\\C-x)\n\
10399 all input characters will have the control modifier applied to them.\n\
10401 Note that the character ?\\C-@, equivalent to the integer zero, does\n\
10402 not count as a control character; rather, it counts as a character\n\
10403 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero\n\
10404 cancels any modification.");
10405 extra_keyboard_modifiers = 0;
10407 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark,
10408 "If an editing command sets this to t, deactivate the mark afterward.\n\
10409 The command loop sets this to nil before each command,\n\
10410 and tests the value when the command returns.\n\
10411 Buffer modification stores t in this variable.");
10412 Vdeactivate_mark = Qnil;
10414 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
10415 "Temporary storage of pre-command-hook or post-command-hook.");
10416 Vcommand_hook_internal = Qnil;
10418 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook,
10419 "Normal hook run before each command is executed.\n\
10420 If an unhandled error happens in running this hook,\n\
10421 the hook value is set to nil, since otherwise the error\n\
10422 might happen repeatedly and make Emacs nonfunctional.");
10423 Vpre_command_hook = Qnil;
10425 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook,
10426 "Normal hook run after each command is executed.\n\
10427 If an unhandled error happens in running this hook,\n\
10428 the hook value is set to nil, since otherwise the error\n\
10429 might happen repeatedly and make Emacs nonfunctional.");
10430 Vpost_command_hook = Qnil;
10432 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook,
10433 "Normal hook run after each command is executed, if idle.\n\
10434 Errors running the hook are caught and ignored.\n\
10435 This feature is obsolete; use idle timers instead. See `etc/NEWS'.");
10436 Vpost_command_idle_hook = Qnil;
10438 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay,
10439 "Delay time before running `post-command-idle-hook'.\n\
10440 This is measured in microseconds.");
10441 post_command_idle_delay = 100000;
10443 #if 0
10444 DEFVAR_LISP ("echo-area-clear-hook", ...,
10445 "Normal hook run when clearing the echo area.");
10446 #endif
10447 Qecho_area_clear_hook = intern ("echo-area-clear-hook");
10448 XSYMBOL (Qecho_area_clear_hook)->value = Qnil;
10450 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag,
10451 "t means menu bar, specified Lucid style, needs to be recomputed.");
10452 Vlucid_menu_bar_dirty_flag = Qnil;
10454 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items,
10455 "List of menu bar items to move to the end of the menu bar.\n\
10456 The elements of the list are event types that may have menu bar bindings.");
10457 Vmenu_bar_final_items = Qnil;
10459 DEFVAR_KBOARD ("overriding-terminal-local-map",
10460 Voverriding_terminal_local_map,
10461 "Per-terminal keymap that overrides all other local keymaps.\n\
10462 If this variable is non-nil, it is used as a keymap instead of the\n\
10463 buffer's local map, and the minor mode keymaps and text property keymaps.\n\
10464 This variable is intended to let commands such as `universal-argumemnt'\n\
10465 set up a different keymap for reading the next command.");
10467 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
10468 "Keymap that overrides all other local keymaps.\n\
10469 If this variable is non-nil, it is used as a keymap instead of the\n\
10470 buffer's local map, and the minor mode keymaps and text property keymaps.");
10471 Voverriding_local_map = Qnil;
10473 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag,
10474 "Non-nil means `overriding-local-map' applies to the menu bar.\n\
10475 Otherwise, the menu bar continues to reflect the buffer's local map\n\
10476 and the minor mode maps regardless of `overriding-local-map'.");
10477 Voverriding_local_map_menu_flag = Qnil;
10479 DEFVAR_LISP ("special-event-map", &Vspecial_event_map,
10480 "Keymap defining bindings for special events to execute at low level.");
10481 Vspecial_event_map = Fcons (intern ("keymap"), Qnil);
10483 DEFVAR_LISP ("track-mouse", &do_mouse_tracking,
10484 "*Non-nil means generate motion events for mouse motion.");
10486 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist,
10487 "Alist of system-specific X windows key symbols.\n\
10488 Each element should have the form (N . SYMBOL) where N is the\n\
10489 numeric keysym code (sans the \"system-specific\" bit 1<<28)\n\
10490 and SYMBOL is its name.");
10492 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list,
10493 "List of deferred actions to be performed at a later time.\n\
10494 The precise format isn't relevant here; we just check whether it is nil.");
10495 Vdeferred_action_list = Qnil;
10497 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function,
10498 "Function to call to handle deferred actions, after each command.\n\
10499 This function is called with no arguments after each command\n\
10500 whenever `deferred-action-list' is non-nil.");
10501 Vdeferred_action_function = Qnil;
10503 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings,
10504 "*Non-nil means show the equivalent key-binding when M-x command has one.\n\
10505 The value can be a length of time to show the message for.\n\
10506 If the value is non-nil and not a number, we wait 2 seconds.");
10507 Vsuggest_key_bindings = Qt;
10509 DEFVAR_LISP ("timer-list", &Vtimer_list,
10510 "List of active absolute time timers in order of increasing time");
10511 Vtimer_list = Qnil;
10513 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list,
10514 "List of active idle-time timers in order of increasing time");
10515 Vtimer_idle_list = Qnil;
10517 DEFVAR_LISP ("input-method-function", &Vinput_method_function,
10518 "If non-nil, the function that implements the current input method.\n\
10519 It's called with one argument, a printing character that was just read.\n\
10520 \(That means a character with code 040...0176.)\n\
10521 Typically this function uses `read-event' to read additional events.\n\
10522 When it does so, it should first bind `input-method-function' to nil\n\
10523 so it will not be called recursively.\n\
10525 The function should return a list of zero or more events\n\
10526 to be used as input. If it wants to put back some events\n\
10527 to be reconsidered, separately, by the input method,\n\
10528 it can add them to the beginning of `unread-command-events'.\n\
10530 The input method function can find in `input-method-previous-method'\n\
10531 the previous echo area message.\n\
10533 The input method function should refer to the variables\n\
10534 `input-method-use-echo-area' and `input-method-exit-on-first-char'\n\
10535 for guidance on what to do.");
10536 Vinput_method_function = Qnil;
10538 DEFVAR_LISP ("input-method-previous-message",
10539 &Vinput_method_previous_message,
10540 "When `input-method-function' is called, hold the previous echo area message.\n\
10541 This variable exists because `read-event' clears the echo area\n\
10542 before running the input method. It is nil if there was no message.");
10543 Vinput_method_previous_message = Qnil;
10545 DEFVAR_LISP ("show-help-function", &Vshow_help_function,
10546 "If non-nil, the function that implements the display of help.\n\
10547 It's called with one argument, the help string to display.");
10548 Vshow_help_function = Qnil;
10550 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment,
10551 "If non-nil, suppress point adjustment after executing a command.\n\
10553 After a command is executed, if point is moved into a region that has\n\
10554 special properties (e.g. composition, display), we adjust point to\n\
10555 the boundary of the region. But, several special commands sets this\n\
10556 variable to non-nil, then we suppress the point adjustment.\n\
10558 This variable is set to nil before reading a command, and is checked\n\
10559 just after executing the command");
10560 Vdisable_point_adjustment = Qnil;
10562 DEFVAR_LISP ("global-disable-point-adjustment",
10563 &Vglobal_disable_point_adjustment,
10564 "*If non-nil, always suppress point adjustment.\n\
10566 The default value is nil, in which case, point adjustment are\n\
10567 suppressed only after special commands that set\n\
10568 `disable-point-adjustment' (which see) to non-nil.");
10569 Vglobal_disable_point_adjustment = Qnil;
10572 void
10573 keys_of_keyboard ()
10575 initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
10576 initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
10577 initial_define_key (meta_map, Ctl ('C'), "exit-recursive-edit");
10578 initial_define_key (global_map, Ctl (']'), "abort-recursive-edit");
10579 initial_define_key (meta_map, 'x', "execute-extended-command");
10581 initial_define_lispy_key (Vspecial_event_map, "delete-frame",
10582 "handle-delete-frame");
10583 initial_define_lispy_key (Vspecial_event_map, "iconify-frame",
10584 "ignore-event");
10585 initial_define_lispy_key (Vspecial_event_map, "make-frame-visible",
10586 "ignore-event");