(lispy_accent_codes, lispy_accent_keys): Extended.
[bpt/emacs.git] / src / keyboard.c
1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 01, 02
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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.
11
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.
16
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. */
21
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 "keyboard.h"
31 #include "frame.h"
32 #include "window.h"
33 #include "commands.h"
34 #include "buffer.h"
35 #include "charset.h"
36 #include "disptab.h"
37 #include "dispextern.h"
38 #include "syntax.h"
39 #include "intervals.h"
40 #include "keymap.h"
41 #include "blockinput.h"
42 #include "puresize.h"
43 #include "systime.h"
44 #include "atimer.h"
45 #include <setjmp.h>
46 #include <errno.h>
47
48 #ifdef MSDOS
49 #include "msdos.h"
50 #include <time.h>
51 #else /* not MSDOS */
52 #ifndef VMS
53 #include <sys/ioctl.h>
54 #endif
55 #endif /* not MSDOS */
56
57 #include "syssignal.h"
58 #include "systty.h"
59
60 #include <sys/types.h>
61 #ifdef HAVE_UNISTD_H
62 #include <unistd.h>
63 #endif
64
65 /* This is to get the definitions of the XK_ symbols. */
66 #ifdef HAVE_X_WINDOWS
67 #include "xterm.h"
68 #endif
69
70 #ifdef HAVE_NTGUI
71 #include "w32term.h"
72 #endif /* HAVE_NTGUI */
73
74 #ifdef MAC_OS
75 #include "macterm.h"
76 #endif
77
78 #ifndef USE_CRT_DLL
79 extern int errno;
80 #endif
81
82 /* Variables for blockinput.h: */
83
84 /* Non-zero if interrupt input is blocked right now. */
85 int interrupt_input_blocked;
86
87 /* Nonzero means an input interrupt has arrived
88 during the current critical section. */
89 int interrupt_input_pending;
90
91
92 /* File descriptor to use for input. */
93 extern int input_fd;
94
95 #ifdef HAVE_WINDOW_SYSTEM
96 /* Make all keyboard buffers much bigger when using X windows. */
97 #ifdef MAC_OS8
98 /* But not too big (local data > 32K error) if on Mac OS Classic. */
99 #define KBD_BUFFER_SIZE 512
100 #else
101 #define KBD_BUFFER_SIZE 4096
102 #endif
103 #else /* No X-windows, character input */
104 #define KBD_BUFFER_SIZE 4096
105 #endif /* No X-windows */
106
107 #define abs(x) ((x) >= 0 ? (x) : -(x))
108
109 /* Following definition copied from eval.c */
110
111 struct backtrace
112 {
113 struct backtrace *next;
114 Lisp_Object *function;
115 Lisp_Object *args; /* Points to vector of args. */
116 int nargs; /* length of vector. If nargs is UNEVALLED,
117 args points to slot holding list of
118 unevalled args */
119 char evalargs;
120 };
121
122 #ifdef MULTI_KBOARD
123 KBOARD *initial_kboard;
124 KBOARD *current_kboard;
125 KBOARD *all_kboards;
126 int single_kboard;
127 #else
128 KBOARD the_only_kboard;
129 #endif
130
131 /* Non-nil disable property on a command means
132 do not execute it; call disabled-command-hook's value instead. */
133 Lisp_Object Qdisabled, Qdisabled_command_hook;
134
135 #define NUM_RECENT_KEYS (100)
136 int recent_keys_index; /* Index for storing next element into recent_keys */
137 int total_keys; /* Total number of elements stored into recent_keys */
138 Lisp_Object recent_keys; /* A vector, holding the last 100 keystrokes */
139
140 /* Vector holding the key sequence that invoked the current command.
141 It is reused for each command, and it may be longer than the current
142 sequence; this_command_key_count indicates how many elements
143 actually mean something.
144 It's easier to staticpro a single Lisp_Object than an array. */
145 Lisp_Object this_command_keys;
146 int this_command_key_count;
147
148 /* This vector is used as a buffer to record the events that were actually read
149 by read_key_sequence. */
150 Lisp_Object raw_keybuf;
151 int raw_keybuf_count;
152
153 #define GROW_RAW_KEYBUF \
154 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
155 { \
156 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
157 Lisp_Object new; \
158 new = Fmake_vector (make_number (newsize), Qnil); \
159 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
160 raw_keybuf_count * sizeof (Lisp_Object)); \
161 raw_keybuf = new; \
162 }
163
164 /* Number of elements of this_command_keys
165 that precede this key sequence. */
166 int this_single_command_key_start;
167
168 /* Record values of this_command_key_count and echo_length ()
169 before this command was read. */
170 static int before_command_key_count;
171 static int before_command_echo_length;
172 /* Values of before_command_key_count and before_command_echo_length
173 saved by reset-this-command-lengths. */
174 static int before_command_key_count_1;
175 static int before_command_echo_length_1;
176 /* Flag set by reset-this-command-lengths,
177 saying to reset the lengths when add_command_key is called. */
178 static int before_command_restore_flag;
179
180 extern int minbuf_level;
181
182 extern int message_enable_multibyte;
183
184 extern struct backtrace *backtrace_list;
185
186 /* If non-nil, the function that implements the display of help.
187 It's called with one argument, the help string to display. */
188
189 Lisp_Object Vshow_help_function;
190
191 /* If a string, the message displayed before displaying a help-echo
192 in the echo area. */
193
194 Lisp_Object Vpre_help_message;
195
196 /* Nonzero means do menu prompting. */
197
198 static int menu_prompting;
199
200 /* Character to see next line of menu prompt. */
201
202 static Lisp_Object menu_prompt_more_char;
203
204 /* For longjmp to where kbd input is being done. */
205
206 static jmp_buf getcjmp;
207
208 /* True while doing kbd input. */
209 int waiting_for_input;
210
211 /* True while displaying for echoing. Delays C-g throwing. */
212
213 int echoing;
214
215 /* Non-null means we can start echoing at the next input pause even
216 though there is something in the echo area. */
217
218 static struct kboard *ok_to_echo_at_next_pause;
219
220 /* The kboard last echoing, or null for none. Reset to 0 in
221 cancel_echoing. If non-null, and a current echo area message
222 exists, and echo_message_buffer is eq to the current message
223 buffer, we know that the message comes from echo_kboard. */
224
225 struct kboard *echo_kboard;
226
227 /* The buffer used for echoing. Set in echo_now, reset in
228 cancel_echoing. */
229
230 Lisp_Object echo_message_buffer;
231
232 /* Nonzero means disregard local maps for the menu bar. */
233 static int inhibit_local_menu_bar_menus;
234
235 /* Nonzero means C-g should cause immediate error-signal. */
236 int immediate_quit;
237
238 /* The user's ERASE setting. */
239 Lisp_Object Vtty_erase_char;
240
241 /* Character to recognize as the help char. */
242 Lisp_Object Vhelp_char;
243
244 /* List of other event types to recognize as meaning "help". */
245 Lisp_Object Vhelp_event_list;
246
247 /* Form to execute when help char is typed. */
248 Lisp_Object Vhelp_form;
249
250 /* Command to run when the help character follows a prefix key. */
251 Lisp_Object Vprefix_help_command;
252
253 /* List of items that should move to the end of the menu bar. */
254 Lisp_Object Vmenu_bar_final_items;
255
256 /* Non-nil means show the equivalent key-binding for
257 any M-x command that has one.
258 The value can be a length of time to show the message for.
259 If the value is non-nil and not a number, we wait 2 seconds. */
260 Lisp_Object Vsuggest_key_bindings;
261
262 /* How long to display an echo-area message when the minibuffer is active.
263 If the value is not a number, such messages don't time out. */
264 Lisp_Object Vminibuffer_message_timeout;
265
266 /* Character that causes a quit. Normally C-g.
267
268 If we are running on an ordinary terminal, this must be an ordinary
269 ASCII char, since we want to make it our interrupt character.
270
271 If we are not running on an ordinary terminal, it still needs to be
272 an ordinary ASCII char. This character needs to be recognized in
273 the input interrupt handler. At this point, the keystroke is
274 represented as a struct input_event, while the desired quit
275 character is specified as a lispy event. The mapping from struct
276 input_events to lispy events cannot run in an interrupt handler,
277 and the reverse mapping is difficult for anything but ASCII
278 keystrokes.
279
280 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
281 ASCII character. */
282 int quit_char;
283
284 extern Lisp_Object current_global_map;
285 extern int minibuf_level;
286
287 /* If non-nil, this is a map that overrides all other local maps. */
288 Lisp_Object Voverriding_local_map;
289
290 /* If non-nil, Voverriding_local_map applies to the menu bar. */
291 Lisp_Object Voverriding_local_map_menu_flag;
292
293 /* Keymap that defines special misc events that should
294 be processed immediately at a low level. */
295 Lisp_Object Vspecial_event_map;
296
297 /* Current depth in recursive edits. */
298 int command_loop_level;
299
300 /* Total number of times command_loop has read a key sequence. */
301 EMACS_INT num_input_keys;
302
303 /* Last input character read as a command. */
304 Lisp_Object last_command_char;
305
306 /* Last input character read as a command, not counting menus
307 reached by the mouse. */
308 Lisp_Object last_nonmenu_event;
309
310 /* Last input character read for any purpose. */
311 Lisp_Object last_input_char;
312
313 /* If not Qnil, a list of objects to be read as subsequent command input. */
314 Lisp_Object Vunread_command_events;
315
316 /* If not Qnil, a list of objects to be read as subsequent command input
317 including input method processing. */
318 Lisp_Object Vunread_input_method_events;
319
320 /* If not Qnil, a list of objects to be read as subsequent command input
321 but NOT including input method processing. */
322 Lisp_Object Vunread_post_input_method_events;
323
324 /* If not -1, an event to be read as subsequent command input. */
325 EMACS_INT unread_command_char;
326
327 /* If not Qnil, this is a switch-frame event which we decided to put
328 off until the end of a key sequence. This should be read as the
329 next command input, after any unread_command_events.
330
331 read_key_sequence uses this to delay switch-frame events until the
332 end of the key sequence; Fread_char uses it to put off switch-frame
333 events until a non-ASCII event is acceptable as input. */
334 Lisp_Object unread_switch_frame;
335
336 /* A mask of extra modifier bits to put into every keyboard char. */
337 EMACS_INT extra_keyboard_modifiers;
338
339 /* Char to use as prefix when a meta character is typed in.
340 This is bound on entry to minibuffer in case ESC is changed there. */
341
342 Lisp_Object meta_prefix_char;
343
344 /* Last size recorded for a current buffer which is not a minibuffer. */
345 static int last_non_minibuf_size;
346
347 /* Number of idle seconds before an auto-save and garbage collection. */
348 static Lisp_Object Vauto_save_timeout;
349
350 /* Total number of times read_char has returned. */
351 int num_input_events;
352
353 /* Total number of times read_char has returned, outside of macros. */
354 EMACS_INT num_nonmacro_input_events;
355
356 /* Auto-save automatically when this many characters have been typed
357 since the last time. */
358
359 static EMACS_INT auto_save_interval;
360
361 /* Value of num_nonmacro_input_events as of last auto save. */
362
363 int last_auto_save;
364
365 /* The command being executed by the command loop.
366 Commands may set this, and the value set will be copied into
367 current_kboard->Vlast_command instead of the actual command. */
368 Lisp_Object Vthis_command;
369
370 /* This is like Vthis_command, except that commands never set it. */
371 Lisp_Object real_this_command;
372
373 /* If the lookup of the command returns a binding, the original
374 command is stored in this-original-command. It is nil otherwise. */
375 Lisp_Object Vthis_original_command;
376
377 /* The value of point when the last command was executed. */
378 int last_point_position;
379
380 /* The buffer that was current when the last command was started. */
381 Lisp_Object last_point_position_buffer;
382
383 /* The frame in which the last input event occurred, or Qmacro if the
384 last event came from a macro. We use this to determine when to
385 generate switch-frame events. This may be cleared by functions
386 like Fselect_frame, to make sure that a switch-frame event is
387 generated by the next character. */
388 Lisp_Object internal_last_event_frame;
389
390 /* A user-visible version of the above, intended to allow users to
391 figure out where the last event came from, if the event doesn't
392 carry that information itself (i.e. if it was a character). */
393 Lisp_Object Vlast_event_frame;
394
395 /* The timestamp of the last input event we received from the X server.
396 X Windows wants this for selection ownership. */
397 unsigned long last_event_timestamp;
398
399 Lisp_Object Qself_insert_command;
400 Lisp_Object Qforward_char;
401 Lisp_Object Qbackward_char;
402 Lisp_Object Qundefined;
403 Lisp_Object Qtimer_event_handler;
404
405 /* read_key_sequence stores here the command definition of the
406 key sequence that it reads. */
407 Lisp_Object read_key_sequence_cmd;
408
409 /* Echo unfinished commands after this many seconds of pause. */
410 Lisp_Object Vecho_keystrokes;
411
412 /* Form to evaluate (if non-nil) when Emacs is started. */
413 Lisp_Object Vtop_level;
414
415 /* User-supplied string to translate input characters through. */
416 Lisp_Object Vkeyboard_translate_table;
417
418 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
419 extern Lisp_Object Vfunction_key_map;
420
421 /* Another keymap that maps key sequences into key sequences.
422 This one takes precedence over ordinary definitions. */
423 extern Lisp_Object Vkey_translation_map;
424
425 /* If non-nil, this implements the current input method. */
426 Lisp_Object Vinput_method_function;
427 Lisp_Object Qinput_method_function;
428
429 /* When we call Vinput_method_function,
430 this holds the echo area message that was just erased. */
431 Lisp_Object Vinput_method_previous_message;
432
433 /* Non-nil means deactivate the mark at end of this command. */
434 Lisp_Object Vdeactivate_mark;
435
436 /* Menu bar specified in Lucid Emacs fashion. */
437
438 Lisp_Object Vlucid_menu_bar_dirty_flag;
439 Lisp_Object Qrecompute_lucid_menubar, Qactivate_menubar_hook;
440
441 Lisp_Object Qecho_area_clear_hook;
442
443 /* Hooks to run before and after each command. */
444 Lisp_Object Qpre_command_hook, Vpre_command_hook;
445 Lisp_Object Qpost_command_hook, Vpost_command_hook;
446 Lisp_Object Qcommand_hook_internal, Vcommand_hook_internal;
447 /* Hook run after a command if there's no more input soon. */
448 Lisp_Object Qpost_command_idle_hook, Vpost_command_idle_hook;
449
450 /* Delay time in microseconds before running post-command-idle-hook. */
451 EMACS_INT post_command_idle_delay;
452
453 /* List of deferred actions to be performed at a later time.
454 The precise format isn't relevant here; we just check whether it is nil. */
455 Lisp_Object Vdeferred_action_list;
456
457 /* Function to call to handle deferred actions, when there are any. */
458 Lisp_Object Vdeferred_action_function;
459 Lisp_Object Qdeferred_action_function;
460
461 Lisp_Object Qinput_method_exit_on_first_char;
462 Lisp_Object Qinput_method_use_echo_area;
463
464 /* File in which we write all commands we read. */
465 FILE *dribble;
466
467 /* Nonzero if input is available. */
468 int input_pending;
469
470 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
471 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
472
473 int meta_key;
474
475 /* Non-zero means force key bindings update in parse_menu_item. */
476
477 int update_menu_bindings;
478
479 extern char *pending_malloc_warning;
480
481 /* Circular buffer for pre-read keyboard input. */
482
483 static struct input_event kbd_buffer[KBD_BUFFER_SIZE];
484
485 /* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
486
487 The interrupt-level event handlers will never enqueue an event on a
488 frame which is not in Vframe_list, and once an event is dequeued,
489 internal_last_event_frame or the event itself points to the frame.
490 So that's all fine.
491
492 But while the event is sitting in the queue, it's completely
493 unprotected. Suppose the user types one command which will run for
494 a while and then delete a frame, and then types another event at
495 the frame that will be deleted, before the command gets around to
496 it. Suppose there are no references to this frame elsewhere in
497 Emacs, and a GC occurs before the second event is dequeued. Now we
498 have an event referring to a freed frame, which will crash Emacs
499 when it is dequeued.
500
501 Similar things happen when an event on a scroll bar is enqueued; the
502 window may be deleted while the event is in the queue.
503
504 So, we use this vector to protect the Lisp_Objects in the event
505 queue. That way, they'll be dequeued as dead frames or windows,
506 but still valid Lisp objects.
507
508 If kbd_buffer[i].kind != NO_EVENT, then
509
510 AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
511 AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
512
513 static Lisp_Object kbd_buffer_gcpro;
514
515 /* Pointer to next available character in kbd_buffer.
516 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
517 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
518 next available char is in kbd_buffer[0]. */
519 static struct input_event *kbd_fetch_ptr;
520
521 /* Pointer to next place to store character in kbd_buffer. This
522 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
523 character should go in kbd_buffer[0]. */
524 static struct input_event * volatile kbd_store_ptr;
525
526 /* The above pair of variables forms a "queue empty" flag. When we
527 enqueue a non-hook event, we increment kbd_store_ptr. When we
528 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
529 there is input available iff the two pointers are not equal.
530
531 Why not just have a flag set and cleared by the enqueuing and
532 dequeuing functions? Such a flag could be screwed up by interrupts
533 at inopportune times. */
534
535 /* If this flag is non-nil, we check mouse_moved to see when the
536 mouse moves, and motion events will appear in the input stream.
537 Otherwise, mouse motion is ignored. */
538 Lisp_Object do_mouse_tracking;
539
540 /* Symbols to head events. */
541 Lisp_Object Qmouse_movement;
542 Lisp_Object Qscroll_bar_movement;
543 Lisp_Object Qswitch_frame;
544 Lisp_Object Qdelete_frame;
545 Lisp_Object Qiconify_frame;
546 Lisp_Object Qmake_frame_visible;
547 Lisp_Object Qselect_window;
548 Lisp_Object Qhelp_echo;
549
550 /* Symbols to denote kinds of events. */
551 Lisp_Object Qfunction_key;
552 Lisp_Object Qmouse_click;
553 #if defined(WINDOWSNT) || defined(MAC_OSX)
554 Lisp_Object Qmouse_wheel;
555 #endif
556 #ifdef WINDOWSNT
557 Lisp_Object Qlanguage_change;
558 #endif
559 Lisp_Object Qdrag_n_drop;
560 Lisp_Object Qsave_session;
561
562 /* Lisp_Object Qmouse_movement; - also an event header */
563
564 /* Properties of event headers. */
565 Lisp_Object Qevent_kind;
566 Lisp_Object Qevent_symbol_elements;
567
568 /* menu item parts */
569 Lisp_Object Qmenu_alias;
570 Lisp_Object Qmenu_enable;
571 Lisp_Object QCenable, QCvisible, QChelp, QCfilter, QCkeys, QCkey_sequence;
572 Lisp_Object QCbutton, QCtoggle, QCradio;
573 extern Lisp_Object Vdefine_key_rebound_commands;
574 extern Lisp_Object Qmenu_item;
575
576 /* An event header symbol HEAD may have a property named
577 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
578 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
579 mask of modifiers applied to it. If present, this is used to help
580 speed up parse_modifiers. */
581 Lisp_Object Qevent_symbol_element_mask;
582
583 /* An unmodified event header BASE may have a property named
584 Qmodifier_cache, which is an alist mapping modifier masks onto
585 modified versions of BASE. If present, this helps speed up
586 apply_modifiers. */
587 Lisp_Object Qmodifier_cache;
588
589 /* Symbols to use for parts of windows. */
590 Lisp_Object Qmode_line;
591 Lisp_Object Qvertical_line;
592 Lisp_Object Qvertical_scroll_bar;
593 Lisp_Object Qmenu_bar;
594 extern Lisp_Object Qleft_margin, Qright_margin;
595
596 Lisp_Object recursive_edit_unwind (), command_loop ();
597 Lisp_Object Fthis_command_keys ();
598 Lisp_Object Qextended_command_history;
599 EMACS_TIME timer_check ();
600
601 extern Lisp_Object Vhistory_length;
602
603 extern char *x_get_keysym_name ();
604
605 static void record_menu_key ();
606
607 Lisp_Object Qpolling_period;
608
609 /* List of absolute timers. Appears in order of next scheduled event. */
610 Lisp_Object Vtimer_list;
611
612 /* List of idle time timers. Appears in order of next scheduled event. */
613 Lisp_Object Vtimer_idle_list;
614
615 /* Incremented whenever a timer is run. */
616 int timers_run;
617
618 extern Lisp_Object Vprint_level, Vprint_length;
619
620 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
621 happens. */
622 EMACS_TIME *input_available_clear_time;
623
624 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
625 Default is 1 if INTERRUPT_INPUT is defined. */
626 int interrupt_input;
627
628 /* Nonzero while interrupts are temporarily deferred during redisplay. */
629 int interrupts_deferred;
630
631 /* Nonzero means use ^S/^Q for flow control. */
632 int flow_control;
633
634 /* Allow m- file to inhibit use of FIONREAD. */
635 #ifdef BROKEN_FIONREAD
636 #undef FIONREAD
637 #endif
638
639 /* We are unable to use interrupts if FIONREAD is not available,
640 so flush SIGIO so we won't try. */
641 #ifndef FIONREAD
642 #ifdef SIGIO
643 #undef SIGIO
644 #endif
645 #endif
646
647 /* If we support a window system, turn on the code to poll periodically
648 to detect C-g. It isn't actually used when doing interrupt input. */
649 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
650 #define POLL_FOR_INPUT
651 #endif
652
653 /* After a command is executed, if point is moved into a region that
654 has specific properties (e.g. composition, display), we adjust
655 point to the boundary of the region. But, if a command sets this
656 variable to non-nil, we suppress this point adjustment. This
657 variable is set to nil before reading a command. */
658
659 Lisp_Object Vdisable_point_adjustment;
660
661 /* If non-nil, always disable point adjustment. */
662
663 Lisp_Object Vglobal_disable_point_adjustment;
664
665 /* The time when Emacs started being idle. */
666
667 static EMACS_TIME timer_idleness_start_time;
668
669 /* After Emacs stops being idle, this saves the last value
670 of timer_idleness_start_time from when it was idle. */
671
672 static EMACS_TIME timer_last_idleness_start_time;
673
674 \f
675 /* Global variable declarations. */
676
677 /* Function for init_keyboard to call with no args (if nonzero). */
678 void (*keyboard_init_hook) ();
679
680 static int read_avail_input P_ ((int));
681 static void get_input_pending P_ ((int *, int));
682 static void get_filtered_input_pending P_ ((int *, int, int));
683 static int readable_events P_ ((int));
684 static int readable_filtered_events P_ ((int, int));
685 static Lisp_Object read_char_x_menu_prompt P_ ((int, Lisp_Object *,
686 Lisp_Object, int *));
687 static Lisp_Object read_char_x_menu_prompt ();
688 static Lisp_Object read_char_minibuf_menu_prompt P_ ((int, int,
689 Lisp_Object *));
690 static Lisp_Object make_lispy_event P_ ((struct input_event *));
691 #ifdef HAVE_MOUSE
692 static Lisp_Object make_lispy_movement P_ ((struct frame *, Lisp_Object,
693 enum scroll_bar_part,
694 Lisp_Object, Lisp_Object,
695 unsigned long));
696 #endif
697 static Lisp_Object modify_event_symbol P_ ((int, unsigned, Lisp_Object,
698 Lisp_Object, char **,
699 Lisp_Object *, unsigned));
700 static Lisp_Object make_lispy_switch_frame P_ ((Lisp_Object));
701 static int parse_solitary_modifier P_ ((Lisp_Object));
702 static int parse_solitary_modifier ();
703 static void save_getcjmp P_ ((jmp_buf));
704 static void save_getcjmp ();
705 static void restore_getcjmp P_ ((jmp_buf));
706 static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
707 static void clear_event P_ ((struct input_event *));
708 static void any_kboard_state P_ ((void));
709
710 /* Nonzero means don't try to suspend even if the operating system seems
711 to support it. */
712 static int cannot_suspend;
713
714 /* Install the string STR as the beginning of the string of echoing,
715 so that it serves as a prompt for the next character.
716 Also start echoing. */
717
718 void
719 echo_prompt (str)
720 Lisp_Object str;
721 {
722 current_kboard->echo_string = str;
723 current_kboard->echo_after_prompt = SCHARS (str);
724 echo_now ();
725 }
726
727 /* Add C to the echo string, if echoing is going on.
728 C can be a character, which is printed prettily ("M-C-x" and all that
729 jazz), or a symbol, whose name is printed. */
730
731 void
732 echo_char (c)
733 Lisp_Object c;
734 {
735 if (current_kboard->immediate_echo)
736 {
737 int size = KEY_DESCRIPTION_SIZE + 100;
738 char *buffer = (char *) alloca (size);
739 char *ptr = buffer;
740 Lisp_Object echo_string;
741
742 echo_string = current_kboard->echo_string;
743
744 /* If someone has passed us a composite event, use its head symbol. */
745 c = EVENT_HEAD (c);
746
747 if (INTEGERP (c))
748 {
749 ptr = push_key_description (XINT (c), ptr, 1);
750 }
751 else if (SYMBOLP (c))
752 {
753 Lisp_Object name = SYMBOL_NAME (c);
754 int nbytes = SBYTES (name);
755
756 if (size - (ptr - buffer) < nbytes)
757 {
758 int offset = ptr - buffer;
759 size = max (2 * size, size + nbytes);
760 buffer = (char *) alloca (size);
761 ptr = buffer + offset;
762 }
763
764 ptr += copy_text (SDATA (name), ptr, nbytes,
765 STRING_MULTIBYTE (name), 1);
766 }
767
768 if ((NILP (echo_string) || SCHARS (echo_string) == 0)
769 && help_char_p (c))
770 {
771 const char *text = " (Type ? for further options)";
772 int len = strlen (text);
773
774 if (size - (ptr - buffer) < len)
775 {
776 int offset = ptr - buffer;
777 size += len;
778 buffer = (char *) alloca (size);
779 ptr = buffer + offset;
780 }
781
782 bcopy (text, ptr, len);
783 ptr += len;
784 }
785
786 /* Replace a dash from echo_dash with a space, otherwise
787 add a space at the end as a separator between keys. */
788 if (STRINGP (echo_string)
789 && SCHARS (echo_string) > 0)
790 {
791 Lisp_Object last_char, idx;
792
793 idx = make_number (SCHARS (echo_string) - 1);
794 last_char = Faref (echo_string, idx);
795
796 if (XINT (last_char) == '-')
797 Faset (echo_string, idx, make_number (' '));
798 else
799 echo_string = concat2 (echo_string, build_string (" "));
800 }
801
802 current_kboard->echo_string
803 = concat2 (echo_string, make_string (buffer, ptr - buffer));
804
805 echo_now ();
806 }
807 }
808
809 /* Temporarily add a dash to the end of the echo string if it's not
810 empty, so that it serves as a mini-prompt for the very next character. */
811
812 void
813 echo_dash ()
814 {
815 /* Do nothing if not echoing at all. */
816 if (NILP (current_kboard->echo_string))
817 return;
818
819 if (!current_kboard->immediate_echo
820 && SCHARS (current_kboard->echo_string) == 0)
821 return;
822
823 /* Do nothing if we just printed a prompt. */
824 if (current_kboard->echo_after_prompt
825 == SCHARS (current_kboard->echo_string))
826 return;
827
828 /* Put a dash at the end of the buffer temporarily,
829 but make it go away when the next character is added. */
830 current_kboard->echo_string = concat2 (current_kboard->echo_string,
831 build_string ("-"));
832 echo_now ();
833 }
834
835 /* Display the current echo string, and begin echoing if not already
836 doing so. */
837
838 void
839 echo_now ()
840 {
841 if (!current_kboard->immediate_echo)
842 {
843 int i;
844 current_kboard->immediate_echo = 1;
845
846 for (i = 0; i < this_command_key_count; i++)
847 {
848 Lisp_Object c;
849 c = XVECTOR (this_command_keys)->contents[i];
850 if (! (EVENT_HAS_PARAMETERS (c)
851 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
852 echo_char (c);
853 }
854 echo_dash ();
855 }
856
857 echoing = 1;
858 message3_nolog (current_kboard->echo_string,
859 SBYTES (current_kboard->echo_string),
860 STRING_MULTIBYTE (current_kboard->echo_string));
861 echoing = 0;
862
863 /* Record in what buffer we echoed, and from which kboard. */
864 echo_message_buffer = echo_area_buffer[0];
865 echo_kboard = current_kboard;
866
867 if (waiting_for_input && !NILP (Vquit_flag))
868 quit_throw_to_read_char ();
869 }
870
871 /* Turn off echoing, for the start of a new command. */
872
873 void
874 cancel_echoing ()
875 {
876 current_kboard->immediate_echo = 0;
877 current_kboard->echo_after_prompt = -1;
878 current_kboard->echo_string = Qnil;
879 ok_to_echo_at_next_pause = NULL;
880 echo_kboard = NULL;
881 echo_message_buffer = Qnil;
882 }
883
884 /* Return the length of the current echo string. */
885
886 static int
887 echo_length ()
888 {
889 return (STRINGP (current_kboard->echo_string)
890 ? SCHARS (current_kboard->echo_string)
891 : 0);
892 }
893
894 /* Truncate the current echo message to its first LEN chars.
895 This and echo_char get used by read_key_sequence when the user
896 switches frames while entering a key sequence. */
897
898 static void
899 echo_truncate (nchars)
900 int nchars;
901 {
902 if (STRINGP (current_kboard->echo_string))
903 current_kboard->echo_string
904 = Fsubstring (current_kboard->echo_string,
905 make_number (0), make_number (nchars));
906 truncate_echo_area (nchars);
907 }
908
909 \f
910 /* Functions for manipulating this_command_keys. */
911 static void
912 add_command_key (key)
913 Lisp_Object key;
914 {
915 /* If reset-this-command-length was called recently, obey it now.
916 See the doc string of that function for an explanation of why. */
917 if (before_command_restore_flag)
918 {
919 this_command_key_count = before_command_key_count_1;
920 if (this_command_key_count < this_single_command_key_start)
921 this_single_command_key_start = this_command_key_count;
922 echo_truncate (before_command_echo_length_1);
923 before_command_restore_flag = 0;
924 }
925
926 if (this_command_key_count >= ASIZE (this_command_keys))
927 this_command_keys = larger_vector (this_command_keys,
928 2 * ASIZE (this_command_keys),
929 Qnil);
930
931 AREF (this_command_keys, this_command_key_count) = key;
932 ++this_command_key_count;
933 }
934
935 \f
936 Lisp_Object
937 recursive_edit_1 ()
938 {
939 int count = SPECPDL_INDEX ();
940 Lisp_Object val;
941
942 if (command_loop_level > 0)
943 {
944 specbind (Qstandard_output, Qt);
945 specbind (Qstandard_input, Qt);
946 }
947
948 #ifdef HAVE_X_WINDOWS
949 /* The command loop has started an hourglass timer, so we have to
950 cancel it here, otherwise it will fire because the recursive edit
951 can take some time. Do not check for display_hourglass_p here,
952 because it could already be nil. */
953 cancel_hourglass ();
954 #endif
955
956 /* This function may have been called from a debugger called from
957 within redisplay, for instance by Edebugging a function called
958 from fontification-functions. We want to allow redisplay in
959 the debugging session.
960
961 The recursive edit is left with a `(throw exit ...)'. The `exit'
962 tag is not caught anywhere in redisplay, i.e. when we leave the
963 recursive edit, the original redisplay leading to the recursive
964 edit will be unwound. The outcome should therefore be safe. */
965 specbind (Qinhibit_redisplay, Qnil);
966 redisplaying_p = 0;
967
968 val = command_loop ();
969 if (EQ (val, Qt))
970 Fsignal (Qquit, Qnil);
971 /* Handle throw from read_minibuf when using minibuffer
972 while it's active but we're in another window. */
973 if (STRINGP (val))
974 Fsignal (Qerror, Fcons (val, Qnil));
975
976 return unbind_to (count, Qnil);
977 }
978
979 /* When an auto-save happens, record the "time", and don't do again soon. */
980
981 void
982 record_auto_save ()
983 {
984 last_auto_save = num_nonmacro_input_events;
985 }
986
987 /* Make an auto save happen as soon as possible at command level. */
988
989 void
990 force_auto_save_soon ()
991 {
992 last_auto_save = - auto_save_interval - 1;
993
994 record_asynch_buffer_change ();
995 }
996 \f
997 DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
998 doc: /* Invoke the editor command loop recursively.
999 To get out of the recursive edit, a command can do `(throw 'exit nil)';
1000 that tells this function to return.
1001 Alternately, `(throw 'exit t)' makes this function signal an error.
1002 This function is called by the editor initialization to begin editing. */)
1003 ()
1004 {
1005 int count = SPECPDL_INDEX ();
1006 Lisp_Object buffer;
1007
1008 command_loop_level++;
1009 update_mode_lines = 1;
1010
1011 if (command_loop_level
1012 && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
1013 buffer = Fcurrent_buffer ();
1014 else
1015 buffer = Qnil;
1016
1017 /* If we leave recursive_edit_1 below with a `throw' for instance,
1018 like it is done in the splash screen display, we have to
1019 make sure that we restore single_kboard as command_loop_1
1020 would have done if it were left normally. */
1021 record_unwind_protect (recursive_edit_unwind,
1022 Fcons (buffer, single_kboard ? Qt : Qnil));
1023
1024 recursive_edit_1 ();
1025 return unbind_to (count, Qnil);
1026 }
1027
1028 Lisp_Object
1029 recursive_edit_unwind (info)
1030 Lisp_Object info;
1031 {
1032 if (BUFFERP (XCAR (info)))
1033 Fset_buffer (XCAR (info));
1034
1035 if (NILP (XCDR (info)))
1036 any_kboard_state ();
1037 else
1038 single_kboard_state ();
1039
1040 command_loop_level--;
1041 update_mode_lines = 1;
1042 return Qnil;
1043 }
1044
1045 \f
1046 static void
1047 any_kboard_state ()
1048 {
1049 #ifdef MULTI_KBOARD
1050 #if 0 /* Theory: if there's anything in Vunread_command_events,
1051 it will right away be read by read_key_sequence,
1052 and then if we do switch KBOARDS, it will go into the side
1053 queue then. So we don't need to do anything special here -- rms. */
1054 if (CONSP (Vunread_command_events))
1055 {
1056 current_kboard->kbd_queue
1057 = nconc2 (Vunread_command_events, current_kboard->kbd_queue);
1058 current_kboard->kbd_queue_has_data = 1;
1059 }
1060 Vunread_command_events = Qnil;
1061 #endif
1062 single_kboard = 0;
1063 #endif
1064 }
1065
1066 /* Switch to the single-kboard state, making current_kboard
1067 the only KBOARD from which further input is accepted. */
1068
1069 void
1070 single_kboard_state ()
1071 {
1072 #ifdef MULTI_KBOARD
1073 single_kboard = 1;
1074 #endif
1075 }
1076
1077 /* Maintain a stack of kboards, so other parts of Emacs
1078 can switch temporarily to the kboard of a given frame
1079 and then revert to the previous status. */
1080
1081 struct kboard_stack
1082 {
1083 KBOARD *kboard;
1084 struct kboard_stack *next;
1085 };
1086
1087 static struct kboard_stack *kboard_stack;
1088
1089 void
1090 push_frame_kboard (f)
1091 FRAME_PTR f;
1092 {
1093 #ifdef MULTI_KBOARD
1094 struct kboard_stack *p
1095 = (struct kboard_stack *) xmalloc (sizeof (struct kboard_stack));
1096
1097 p->next = kboard_stack;
1098 p->kboard = current_kboard;
1099 kboard_stack = p;
1100
1101 current_kboard = FRAME_KBOARD (f);
1102 #endif
1103 }
1104
1105 void
1106 pop_frame_kboard ()
1107 {
1108 #ifdef MULTI_KBOARD
1109 struct kboard_stack *p = kboard_stack;
1110 current_kboard = p->kboard;
1111 kboard_stack = p->next;
1112 xfree (p);
1113 #endif
1114 }
1115 \f
1116 /* Handle errors that are not handled at inner levels
1117 by printing an error message and returning to the editor command loop. */
1118
1119 Lisp_Object
1120 cmd_error (data)
1121 Lisp_Object data;
1122 {
1123 Lisp_Object old_level, old_length;
1124 char macroerror[50];
1125
1126 #ifdef HAVE_X_WINDOWS
1127 if (display_hourglass_p)
1128 cancel_hourglass ();
1129 #endif
1130
1131 if (!NILP (executing_macro))
1132 {
1133 if (executing_macro_iterations == 1)
1134 sprintf (macroerror, "After 1 kbd macro iteration: ");
1135 else
1136 sprintf (macroerror, "After %d kbd macro iterations: ",
1137 executing_macro_iterations);
1138 }
1139 else
1140 *macroerror = 0;
1141
1142 Vstandard_output = Qt;
1143 Vstandard_input = Qt;
1144 Vexecuting_macro = Qnil;
1145 executing_macro = Qnil;
1146 current_kboard->Vprefix_arg = Qnil;
1147 current_kboard->Vlast_prefix_arg = Qnil;
1148 cancel_echoing ();
1149
1150 /* Avoid unquittable loop if data contains a circular list. */
1151 old_level = Vprint_level;
1152 old_length = Vprint_length;
1153 XSETFASTINT (Vprint_level, 10);
1154 XSETFASTINT (Vprint_length, 10);
1155 cmd_error_internal (data, macroerror);
1156 Vprint_level = old_level;
1157 Vprint_length = old_length;
1158
1159 Vquit_flag = Qnil;
1160
1161 Vinhibit_quit = Qnil;
1162 #ifdef MULTI_KBOARD
1163 any_kboard_state ();
1164 #endif
1165
1166 return make_number (0);
1167 }
1168
1169 /* Take actions on handling an error. DATA is the data that describes
1170 the error.
1171
1172 CONTEXT is a C-string containing ASCII characters only which
1173 describes the context in which the error happened. If we need to
1174 generalize CONTEXT to allow multibyte characters, make it a Lisp
1175 string. */
1176
1177 void
1178 cmd_error_internal (data, context)
1179 Lisp_Object data;
1180 char *context;
1181 {
1182 Lisp_Object stream;
1183 int kill_emacs_p = 0;
1184 struct frame *sf = SELECTED_FRAME ();
1185
1186 Vquit_flag = Qnil;
1187 Vinhibit_quit = Qt;
1188 clear_message (1, 0);
1189
1190 /* If the window system or terminal frame hasn't been initialized
1191 yet, or we're not interactive, it's best to dump this message out
1192 to stderr and exit. */
1193 if (!sf->glyphs_initialized_p
1194 /* This is the case of the frame dumped with Emacs, when we're
1195 running under a window system. */
1196 || (!NILP (Vwindow_system)
1197 && !inhibit_window_system
1198 && FRAME_TERMCAP_P (sf))
1199 || noninteractive)
1200 {
1201 stream = Qexternal_debugging_output;
1202 kill_emacs_p = 1;
1203 }
1204 else
1205 {
1206 Fdiscard_input ();
1207 message_log_maybe_newline ();
1208 bitch_at_user ();
1209 stream = Qt;
1210 }
1211
1212 /* The immediate context is not interesting for Quits,
1213 since they are asyncronous. */
1214 if (EQ (XCAR (data), Qquit))
1215 Vsignaling_function = Qnil;
1216
1217 print_error_message (data, stream, context, Vsignaling_function);
1218
1219 Vsignaling_function = Qnil;
1220
1221 /* If the window system or terminal frame hasn't been initialized
1222 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1223 if (kill_emacs_p)
1224 {
1225 Fterpri (stream);
1226 Fkill_emacs (make_number (-1));
1227 }
1228 }
1229 \f
1230 Lisp_Object command_loop_1 ();
1231 Lisp_Object command_loop_2 ();
1232 Lisp_Object top_level_1 ();
1233
1234 /* Entry to editor-command-loop.
1235 This level has the catches for exiting/returning to editor command loop.
1236 It returns nil to exit recursive edit, t to abort it. */
1237
1238 Lisp_Object
1239 command_loop ()
1240 {
1241 if (command_loop_level > 0 || minibuf_level > 0)
1242 {
1243 Lisp_Object val;
1244 val = internal_catch (Qexit, command_loop_2, Qnil);
1245 executing_macro = Qnil;
1246 return val;
1247 }
1248 else
1249 while (1)
1250 {
1251 internal_catch (Qtop_level, top_level_1, Qnil);
1252 internal_catch (Qtop_level, command_loop_2, Qnil);
1253 executing_macro = Qnil;
1254
1255 /* End of file in -batch run causes exit here. */
1256 if (noninteractive)
1257 Fkill_emacs (Qt);
1258 }
1259 }
1260
1261 /* Here we catch errors in execution of commands within the
1262 editing loop, and reenter the editing loop.
1263 When there is an error, cmd_error runs and returns a non-nil
1264 value to us. A value of nil means that command_loop_1 itself
1265 returned due to end of file (or end of kbd macro). */
1266
1267 Lisp_Object
1268 command_loop_2 ()
1269 {
1270 register Lisp_Object val;
1271
1272 do
1273 val = internal_condition_case (command_loop_1, Qerror, cmd_error);
1274 while (!NILP (val));
1275
1276 return Qnil;
1277 }
1278
1279 Lisp_Object
1280 top_level_2 ()
1281 {
1282 return Feval (Vtop_level);
1283 }
1284
1285 Lisp_Object
1286 top_level_1 ()
1287 {
1288 /* On entry to the outer level, run the startup file */
1289 if (!NILP (Vtop_level))
1290 internal_condition_case (top_level_2, Qerror, cmd_error);
1291 else if (!NILP (Vpurify_flag))
1292 message ("Bare impure Emacs (standard Lisp code not loaded)");
1293 else
1294 message ("Bare Emacs (standard Lisp code not loaded)");
1295 return Qnil;
1296 }
1297
1298 DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
1299 doc: /* Exit all recursive editing levels. */)
1300 ()
1301 {
1302 #ifdef HAVE_X_WINDOWS
1303 if (display_hourglass_p)
1304 cancel_hourglass ();
1305 #endif
1306 return Fthrow (Qtop_level, Qnil);
1307 }
1308
1309 DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
1310 doc: /* Exit from the innermost recursive edit or minibuffer. */)
1311 ()
1312 {
1313 if (command_loop_level > 0 || minibuf_level > 0)
1314 Fthrow (Qexit, Qnil);
1315
1316 error ("No recursive edit is in progress");
1317 return Qnil;
1318 }
1319
1320 DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
1321 doc: /* Abort the command that requested this recursive edit or minibuffer input. */)
1322 ()
1323 {
1324 if (command_loop_level > 0 || minibuf_level > 0)
1325 Fthrow (Qexit, Qt);
1326
1327 error ("No recursive edit is in progress");
1328 return Qnil;
1329 }
1330 \f
1331 /* This is the actual command reading loop,
1332 sans error-handling encapsulation. */
1333
1334 static int read_key_sequence P_ ((Lisp_Object *, int, Lisp_Object,
1335 int, int, int));
1336 void safe_run_hooks P_ ((Lisp_Object));
1337 static void adjust_point_for_property P_ ((int));
1338
1339 Lisp_Object
1340 command_loop_1 ()
1341 {
1342 Lisp_Object cmd;
1343 int lose;
1344 int nonundocount;
1345 Lisp_Object keybuf[30];
1346 int i;
1347 int no_direct;
1348 int prev_modiff;
1349 struct buffer *prev_buffer = NULL;
1350 #ifdef MULTI_KBOARD
1351 int was_locked = single_kboard;
1352 #endif
1353
1354 current_kboard->Vprefix_arg = Qnil;
1355 current_kboard->Vlast_prefix_arg = Qnil;
1356 Vdeactivate_mark = Qnil;
1357 waiting_for_input = 0;
1358 cancel_echoing ();
1359
1360 nonundocount = 0;
1361 this_command_key_count = 0;
1362 this_single_command_key_start = 0;
1363
1364 if (NILP (Vmemory_full))
1365 {
1366 /* Make sure this hook runs after commands that get errors and
1367 throw to top level. */
1368 /* Note that the value cell will never directly contain nil
1369 if the symbol is a local variable. */
1370 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1371 safe_run_hooks (Qpost_command_hook);
1372
1373 /* If displaying a message, resize the echo area window to fit
1374 that message's size exactly. */
1375 if (!NILP (echo_area_buffer[0]))
1376 resize_echo_area_exactly ();
1377
1378 if (!NILP (Vdeferred_action_list))
1379 call0 (Vdeferred_action_function);
1380
1381 if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
1382 {
1383 if (NILP (Vunread_command_events)
1384 && NILP (Vunread_input_method_events)
1385 && NILP (Vunread_post_input_method_events)
1386 && NILP (Vexecuting_macro)
1387 && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
1388 safe_run_hooks (Qpost_command_idle_hook);
1389 }
1390 }
1391
1392 Vmemory_full = Qnil;
1393
1394 /* Do this after running Vpost_command_hook, for consistency. */
1395 current_kboard->Vlast_command = Vthis_command;
1396 current_kboard->Vreal_last_command = real_this_command;
1397
1398 while (1)
1399 {
1400 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1401 Fkill_emacs (Qnil);
1402
1403 /* Make sure the current window's buffer is selected. */
1404 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1405 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1406
1407 /* Display any malloc warning that just came out. Use while because
1408 displaying one warning can cause another. */
1409
1410 while (pending_malloc_warning)
1411 display_malloc_warning ();
1412
1413 no_direct = 0;
1414
1415 Vdeactivate_mark = Qnil;
1416
1417 /* If minibuffer on and echo area in use,
1418 wait a short time and redraw minibuffer. */
1419
1420 if (minibuf_level
1421 && !NILP (echo_area_buffer[0])
1422 && EQ (minibuf_window, echo_area_window)
1423 && NUMBERP (Vminibuffer_message_timeout))
1424 {
1425 /* Bind inhibit-quit to t so that C-g gets read in
1426 rather than quitting back to the minibuffer. */
1427 int count = SPECPDL_INDEX ();
1428 specbind (Qinhibit_quit, Qt);
1429
1430 Fsit_for (Vminibuffer_message_timeout, Qnil, Qnil);
1431 /* Clear the echo area. */
1432 message2 (0, 0, 0);
1433 safe_run_hooks (Qecho_area_clear_hook);
1434
1435 unbind_to (count, Qnil);
1436
1437 /* If a C-g came in before, treat it as input now. */
1438 if (!NILP (Vquit_flag))
1439 {
1440 Vquit_flag = Qnil;
1441 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
1442 }
1443 }
1444
1445 #ifdef C_ALLOCA
1446 alloca (0); /* Cause a garbage collection now */
1447 /* Since we can free the most stuff here. */
1448 #endif /* C_ALLOCA */
1449
1450 #if 0
1451 /* Select the frame that the last event came from. Usually,
1452 switch-frame events will take care of this, but if some lisp
1453 code swallows a switch-frame event, we'll fix things up here.
1454 Is this a good idea? */
1455 if (FRAMEP (internal_last_event_frame)
1456 && !EQ (internal_last_event_frame, selected_frame))
1457 Fselect_frame (internal_last_event_frame, Qnil);
1458 #endif
1459 /* If it has changed current-menubar from previous value,
1460 really recompute the menubar from the value. */
1461 if (! NILP (Vlucid_menu_bar_dirty_flag)
1462 && !NILP (Ffboundp (Qrecompute_lucid_menubar)))
1463 call0 (Qrecompute_lucid_menubar);
1464
1465 before_command_key_count = this_command_key_count;
1466 before_command_echo_length = echo_length ();
1467
1468 Vthis_command = Qnil;
1469 real_this_command = Qnil;
1470
1471 /* Read next key sequence; i gets its length. */
1472 i = read_key_sequence (keybuf, sizeof keybuf / sizeof keybuf[0],
1473 Qnil, 0, 1, 1);
1474
1475 /* A filter may have run while we were reading the input. */
1476 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
1477 Fkill_emacs (Qnil);
1478 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
1479 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
1480
1481 ++num_input_keys;
1482
1483 /* Now we have read a key sequence of length I,
1484 or else I is 0 and we found end of file. */
1485
1486 if (i == 0) /* End of file -- happens only in */
1487 return Qnil; /* a kbd macro, at the end. */
1488 /* -1 means read_key_sequence got a menu that was rejected.
1489 Just loop around and read another command. */
1490 if (i == -1)
1491 {
1492 cancel_echoing ();
1493 this_command_key_count = 0;
1494 this_single_command_key_start = 0;
1495 goto finalize;
1496 }
1497
1498 last_command_char = keybuf[i - 1];
1499
1500 /* If the previous command tried to force a specific window-start,
1501 forget about that, in case this command moves point far away
1502 from that position. But also throw away beg_unchanged and
1503 end_unchanged information in that case, so that redisplay will
1504 update the whole window properly. */
1505 if (!NILP (XWINDOW (selected_window)->force_start))
1506 {
1507 struct buffer *b;
1508 XWINDOW (selected_window)->force_start = Qnil;
1509 b = XBUFFER (XWINDOW (selected_window)->buffer);
1510 BUF_BEG_UNCHANGED (b) = BUF_END_UNCHANGED (b) = 0;
1511 }
1512
1513 cmd = read_key_sequence_cmd;
1514 if (!NILP (Vexecuting_macro))
1515 {
1516 if (!NILP (Vquit_flag))
1517 {
1518 Vexecuting_macro = Qt;
1519 QUIT; /* Make some noise. */
1520 /* Will return since macro now empty. */
1521 }
1522 }
1523
1524 /* Do redisplay processing after this command except in special
1525 cases identified below. */
1526 prev_buffer = current_buffer;
1527 prev_modiff = MODIFF;
1528 last_point_position = PT;
1529 XSETBUFFER (last_point_position_buffer, prev_buffer);
1530
1531 /* By default, we adjust point to a boundary of a region that
1532 has such a property that should be treated intangible
1533 (e.g. composition, display). But, some commands will set
1534 this variable differently. */
1535 Vdisable_point_adjustment = Qnil;
1536
1537 /* Process filters and timers may have messed with deactivate-mark.
1538 reset it before we execute the command. */
1539 Vdeactivate_mark = Qnil;
1540
1541 /* Remap command through active keymaps */
1542 Vthis_original_command = cmd;
1543 if (SYMBOLP (cmd))
1544 {
1545 Lisp_Object cmd1;
1546 if (cmd1 = Fremap_command (cmd), !NILP (cmd1))
1547 cmd = cmd1;
1548 }
1549
1550 /* Execute the command. */
1551
1552 Vthis_command = cmd;
1553 real_this_command = cmd;
1554 /* Note that the value cell will never directly contain nil
1555 if the symbol is a local variable. */
1556 if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
1557 safe_run_hooks (Qpre_command_hook);
1558
1559 if (NILP (Vthis_command))
1560 {
1561 /* nil means key is undefined. */
1562 bitch_at_user ();
1563 current_kboard->defining_kbd_macro = Qnil;
1564 update_mode_lines = 1;
1565 current_kboard->Vprefix_arg = Qnil;
1566 }
1567 else
1568 {
1569 if (NILP (current_kboard->Vprefix_arg) && ! no_direct)
1570 {
1571 /* In case we jump to directly_done. */
1572 Vcurrent_prefix_arg = current_kboard->Vprefix_arg;
1573
1574 /* Recognize some common commands in common situations and
1575 do them directly. */
1576 if (EQ (Vthis_command, Qforward_char) && PT < ZV)
1577 {
1578 struct Lisp_Char_Table *dp
1579 = window_display_table (XWINDOW (selected_window));
1580 lose = FETCH_CHAR (PT_BYTE);
1581 SET_PT (PT + 1);
1582 if ((dp
1583 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1584 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1585 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1586 && (lose >= 0x20 && lose < 0x7f)))
1587 : (lose >= 0x20 && lose < 0x7f))
1588 /* To extract the case of continuation on
1589 wide-column characters. */
1590 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE)) == 1)
1591 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1592 >= MODIFF)
1593 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1594 >= OVERLAY_MODIFF)
1595 && (XFASTINT (XWINDOW (selected_window)->last_point)
1596 == PT - 1)
1597 && !windows_or_buffers_changed
1598 && EQ (current_buffer->selective_display, Qnil)
1599 && !detect_input_pending ()
1600 && NILP (XWINDOW (selected_window)->column_number_displayed)
1601 && NILP (Vexecuting_macro))
1602 direct_output_forward_char (1);
1603 goto directly_done;
1604 }
1605 else if (EQ (Vthis_command, Qbackward_char) && PT > BEGV)
1606 {
1607 struct Lisp_Char_Table *dp
1608 = window_display_table (XWINDOW (selected_window));
1609 SET_PT (PT - 1);
1610 lose = FETCH_CHAR (PT_BYTE);
1611 if ((dp
1612 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
1613 ? XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1
1614 : (NILP (DISP_CHAR_VECTOR (dp, lose))
1615 && (lose >= 0x20 && lose < 0x7f)))
1616 : (lose >= 0x20 && lose < 0x7f))
1617 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1618 >= MODIFF)
1619 && (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1620 >= OVERLAY_MODIFF)
1621 && (XFASTINT (XWINDOW (selected_window)->last_point)
1622 == PT + 1)
1623 && !windows_or_buffers_changed
1624 && EQ (current_buffer->selective_display, Qnil)
1625 && !detect_input_pending ()
1626 && NILP (XWINDOW (selected_window)->column_number_displayed)
1627 && NILP (Vexecuting_macro))
1628 direct_output_forward_char (-1);
1629 goto directly_done;
1630 }
1631 else if (EQ (Vthis_command, Qself_insert_command)
1632 /* Try this optimization only on ascii keystrokes. */
1633 && INTEGERP (last_command_char))
1634 {
1635 unsigned int c = XINT (last_command_char);
1636 int value;
1637 if (NILP (Vexecuting_macro)
1638 && !EQ (minibuf_window, selected_window))
1639 {
1640 if (!nonundocount || nonundocount >= 20)
1641 {
1642 Fundo_boundary ();
1643 nonundocount = 0;
1644 }
1645 nonundocount++;
1646 }
1647
1648 lose = ((XFASTINT (XWINDOW (selected_window)->last_modified)
1649 < MODIFF)
1650 || (XFASTINT (XWINDOW (selected_window)->last_overlay_modified)
1651 < OVERLAY_MODIFF)
1652 || (XFASTINT (XWINDOW (selected_window)->last_point)
1653 != PT)
1654 || MODIFF <= SAVE_MODIFF
1655 || windows_or_buffers_changed
1656 || !EQ (current_buffer->selective_display, Qnil)
1657 || detect_input_pending ()
1658 || !NILP (XWINDOW (selected_window)->column_number_displayed)
1659 || !NILP (Vexecuting_macro));
1660
1661 value = internal_self_insert (c, 0);
1662
1663 if (value == 2)
1664 nonundocount = 0;
1665
1666 /* VALUE == 1 when AFTER-CHANGE functions are
1667 installed which is the case most of the time
1668 because FONT-LOCK installs one. */
1669 if (!lose && !value)
1670 direct_output_for_insert (c);
1671 goto directly_done;
1672 }
1673 }
1674
1675 /* Here for a command that isn't executed directly */
1676
1677 #ifdef HAVE_X_WINDOWS
1678 if (display_hourglass_p
1679 && NILP (Vexecuting_macro))
1680 start_hourglass ();
1681 #endif
1682
1683 nonundocount = 0;
1684 if (NILP (current_kboard->Vprefix_arg))
1685 Fundo_boundary ();
1686 Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
1687
1688 #ifdef HAVE_X_WINDOWS
1689 /* Do not check display_hourglass_p here, because
1690 Fcommand_execute could change it, but we should cancel
1691 hourglass cursor anyway.
1692 But don't cancel the hourglass within a macro
1693 just because a command in the macro finishes. */
1694 if (NILP (Vexecuting_macro))
1695 cancel_hourglass ();
1696 #endif
1697 }
1698 directly_done: ;
1699 current_kboard->Vlast_prefix_arg = Vcurrent_prefix_arg;
1700
1701 /* Note that the value cell will never directly contain nil
1702 if the symbol is a local variable. */
1703 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
1704 safe_run_hooks (Qpost_command_hook);
1705
1706 /* If displaying a message, resize the echo area window to fit
1707 that message's size exactly. */
1708 if (!NILP (echo_area_buffer[0]))
1709 resize_echo_area_exactly ();
1710
1711 if (!NILP (Vdeferred_action_list))
1712 safe_run_hooks (Qdeferred_action_function);
1713
1714 if (!NILP (Vpost_command_idle_hook) && !NILP (Vrun_hooks))
1715 {
1716 if (NILP (Vunread_command_events)
1717 && NILP (Vunread_input_method_events)
1718 && NILP (Vunread_post_input_method_events)
1719 && NILP (Vexecuting_macro)
1720 && !NILP (sit_for (0, post_command_idle_delay, 0, 1, 1)))
1721 safe_run_hooks (Qpost_command_idle_hook);
1722 }
1723
1724 /* If there is a prefix argument,
1725 1) We don't want Vlast_command to be ``universal-argument''
1726 (that would be dumb), so don't set Vlast_command,
1727 2) we want to leave echoing on so that the prefix will be
1728 echoed as part of this key sequence, so don't call
1729 cancel_echoing, and
1730 3) we want to leave this_command_key_count non-zero, so that
1731 read_char will realize that it is re-reading a character, and
1732 not echo it a second time.
1733
1734 If the command didn't actually create a prefix arg,
1735 but is merely a frame event that is transparent to prefix args,
1736 then the above doesn't apply. */
1737 if (NILP (current_kboard->Vprefix_arg) || CONSP (last_command_char))
1738 {
1739 current_kboard->Vlast_command = Vthis_command;
1740 current_kboard->Vreal_last_command = real_this_command;
1741 cancel_echoing ();
1742 this_command_key_count = 0;
1743 this_single_command_key_start = 0;
1744 }
1745
1746 if (!NILP (current_buffer->mark_active) && !NILP (Vrun_hooks))
1747 {
1748 if (!NILP (Vdeactivate_mark) && !NILP (Vtransient_mark_mode))
1749 {
1750 /* We could also call `deactivate'mark'. */
1751 if (EQ (Vtransient_mark_mode, Qlambda))
1752 Vtransient_mark_mode = Qnil;
1753 else
1754 {
1755 current_buffer->mark_active = Qnil;
1756 call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
1757 }
1758 }
1759 else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
1760 call1 (Vrun_hooks, intern ("activate-mark-hook"));
1761 }
1762
1763 finalize:
1764
1765 if (current_buffer == prev_buffer
1766 && last_point_position != PT
1767 && NILP (Vdisable_point_adjustment)
1768 && NILP (Vglobal_disable_point_adjustment))
1769 adjust_point_for_property (last_point_position);
1770
1771 /* Install chars successfully executed in kbd macro. */
1772
1773 if (!NILP (current_kboard->defining_kbd_macro)
1774 && NILP (current_kboard->Vprefix_arg))
1775 finalize_kbd_macro_chars ();
1776
1777 #ifdef MULTI_KBOARD
1778 if (!was_locked)
1779 any_kboard_state ();
1780 #endif
1781 }
1782 }
1783
1784 extern Lisp_Object Qcomposition, Qdisplay;
1785
1786 /* Adjust point to a boundary of a region that has such a property
1787 that should be treated intangible. For the moment, we check
1788 `composition' and `display' property. LAST_PT is the last position
1789 of point. */
1790
1791 static void
1792 adjust_point_for_property (last_pt)
1793 int last_pt;
1794 {
1795 int start, end;
1796 Lisp_Object val;
1797 int check_composition = 1, check_display = 1;
1798
1799 while (check_composition || check_display)
1800 {
1801 if (check_composition
1802 && PT > BEGV && PT < ZV
1803 && get_property_and_range (PT, Qcomposition, &val, &start, &end, Qnil)
1804 && COMPOSITION_VALID_P (start, end, val)
1805 && start < PT && end > PT
1806 && (last_pt <= start || last_pt >= end))
1807 {
1808 if (PT < last_pt)
1809 SET_PT (start);
1810 else
1811 SET_PT (end);
1812 check_display = 1;
1813 }
1814 check_composition = 0;
1815 if (check_display
1816 && PT > BEGV && PT < ZV
1817 && get_property_and_range (PT, Qdisplay, &val, &start, &end, Qnil)
1818 && display_prop_intangible_p (val)
1819 && start < PT && end > PT
1820 && (last_pt <= start || last_pt >= end))
1821 {
1822 if (PT < last_pt)
1823 SET_PT (start);
1824 else
1825 SET_PT (end);
1826 check_composition = 1;
1827 }
1828 check_display = 0;
1829 }
1830 }
1831
1832 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1833
1834 static Lisp_Object
1835 safe_run_hooks_1 (hook)
1836 Lisp_Object hook;
1837 {
1838 return call1 (Vrun_hooks, Vinhibit_quit);
1839 }
1840
1841 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1842
1843 static Lisp_Object
1844 safe_run_hooks_error (data)
1845 Lisp_Object data;
1846 {
1847 return Fset (Vinhibit_quit, Qnil);
1848 }
1849
1850 /* If we get an error while running the hook, cause the hook variable
1851 to be nil. Also inhibit quits, so that C-g won't cause the hook
1852 to mysteriously evaporate. */
1853
1854 void
1855 safe_run_hooks (hook)
1856 Lisp_Object hook;
1857 {
1858 int count = SPECPDL_INDEX ();
1859 specbind (Qinhibit_quit, hook);
1860
1861 internal_condition_case (safe_run_hooks_1, Qt, safe_run_hooks_error);
1862
1863 unbind_to (count, Qnil);
1864 }
1865
1866 \f
1867 /* Number of seconds between polling for input. This is a Lisp
1868 variable that can be bound. */
1869
1870 EMACS_INT polling_period;
1871
1872 /* Nonzero means polling for input is temporarily suppressed. */
1873
1874 int poll_suppress_count;
1875
1876 /* Asynchronous timer for polling. */
1877
1878 struct atimer *poll_timer;
1879
1880
1881 #ifdef POLL_FOR_INPUT
1882
1883 /* Poll for input, so what we catch a C-g if it comes in. This
1884 function is called from x_make_frame_visible, see comment
1885 there. */
1886
1887 void
1888 poll_for_input_1 ()
1889 {
1890 if (interrupt_input_blocked == 0
1891 && !waiting_for_input)
1892 read_avail_input (0);
1893 }
1894
1895 /* Timer callback function for poll_timer. TIMER is equal to
1896 poll_timer. */
1897
1898 void
1899 poll_for_input (timer)
1900 struct atimer *timer;
1901 {
1902 if (poll_suppress_count == 0)
1903 poll_for_input_1 ();
1904 }
1905
1906 #endif /* POLL_FOR_INPUT */
1907
1908 /* Begin signals to poll for input, if they are appropriate.
1909 This function is called unconditionally from various places. */
1910
1911 void
1912 start_polling ()
1913 {
1914 #ifdef POLL_FOR_INPUT
1915 if (read_socket_hook && !interrupt_input)
1916 {
1917 /* Turn alarm handling on unconditionally. It might have
1918 been turned off in process.c. */
1919 turn_on_atimers (1);
1920
1921 /* If poll timer doesn't exist, are we need one with
1922 a different interval, start a new one. */
1923 if (poll_timer == NULL
1924 || EMACS_SECS (poll_timer->interval) != polling_period)
1925 {
1926 EMACS_TIME interval;
1927
1928 if (poll_timer)
1929 cancel_atimer (poll_timer);
1930
1931 EMACS_SET_SECS_USECS (interval, polling_period, 0);
1932 poll_timer = start_atimer (ATIMER_CONTINUOUS, interval,
1933 poll_for_input, NULL);
1934 }
1935
1936 /* Let the timer's callback function poll for input
1937 if this becomes zero. */
1938 --poll_suppress_count;
1939 }
1940 #endif
1941 }
1942
1943 /* Nonzero if we are using polling to handle input asynchronously. */
1944
1945 int
1946 input_polling_used ()
1947 {
1948 #ifdef POLL_FOR_INPUT
1949 return read_socket_hook && !interrupt_input;
1950 #else
1951 return 0;
1952 #endif
1953 }
1954
1955 /* Turn off polling. */
1956
1957 void
1958 stop_polling ()
1959 {
1960 #ifdef POLL_FOR_INPUT
1961 if (read_socket_hook && !interrupt_input)
1962 ++poll_suppress_count;
1963 #endif
1964 }
1965
1966 /* Set the value of poll_suppress_count to COUNT
1967 and start or stop polling accordingly. */
1968
1969 void
1970 set_poll_suppress_count (count)
1971 int count;
1972 {
1973 #ifdef POLL_FOR_INPUT
1974 if (count == 0 && poll_suppress_count != 0)
1975 {
1976 poll_suppress_count = 1;
1977 start_polling ();
1978 }
1979 else if (count != 0 && poll_suppress_count == 0)
1980 {
1981 stop_polling ();
1982 }
1983 poll_suppress_count = count;
1984 #endif
1985 }
1986
1987 /* Bind polling_period to a value at least N.
1988 But don't decrease it. */
1989
1990 void
1991 bind_polling_period (n)
1992 int n;
1993 {
1994 #ifdef POLL_FOR_INPUT
1995 int new = polling_period;
1996
1997 if (n > new)
1998 new = n;
1999
2000 stop_other_atimers (poll_timer);
2001 stop_polling ();
2002 specbind (Qpolling_period, make_number (new));
2003 /* Start a new alarm with the new period. */
2004 start_polling ();
2005 #endif
2006 }
2007 \f
2008 /* Apply the control modifier to CHARACTER. */
2009
2010 int
2011 make_ctrl_char (c)
2012 int c;
2013 {
2014 /* Save the upper bits here. */
2015 int upper = c & ~0177;
2016
2017 c &= 0177;
2018
2019 /* Everything in the columns containing the upper-case letters
2020 denotes a control character. */
2021 if (c >= 0100 && c < 0140)
2022 {
2023 int oc = c;
2024 c &= ~0140;
2025 /* Set the shift modifier for a control char
2026 made from a shifted letter. But only for letters! */
2027 if (oc >= 'A' && oc <= 'Z')
2028 c |= shift_modifier;
2029 }
2030
2031 /* The lower-case letters denote control characters too. */
2032 else if (c >= 'a' && c <= 'z')
2033 c &= ~0140;
2034
2035 /* Include the bits for control and shift
2036 only if the basic ASCII code can't indicate them. */
2037 else if (c >= ' ')
2038 c |= ctrl_modifier;
2039
2040 /* Replace the high bits. */
2041 c |= (upper & ~ctrl_modifier);
2042
2043 return c;
2044 }
2045
2046 /* Display help echo in the echo area.
2047
2048 HELP a string means display that string, HELP nil means clear the
2049 help echo. If HELP is a function, call it with OBJECT and POS as
2050 arguments; the function should return a help string or nil for
2051 none. For all other types of HELP evaluate it to obtain a string.
2052
2053 WINDOW is the window in which the help was generated, if any.
2054 It is nil if not in a window.
2055
2056 If OBJECT is a buffer, POS is the position in the buffer where the
2057 `help-echo' text property was found.
2058
2059 If OBJECT is an overlay, that overlay has a `help-echo' property,
2060 and POS is the position in the overlay's buffer under the mouse.
2061
2062 If OBJECT is a string (an overlay string or a string displayed with
2063 the `display' property). POS is the position in that string under
2064 the mouse.
2065
2066 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2067 echo overwrites a keystroke echo currently displayed in the echo
2068 area.
2069
2070 Note: this function may only be called with HELP nil or a string
2071 from X code running asynchronously. */
2072
2073 void
2074 show_help_echo (help, window, object, pos, ok_to_overwrite_keystroke_echo)
2075 Lisp_Object help, window, object, pos;
2076 int ok_to_overwrite_keystroke_echo;
2077 {
2078 if (!NILP (help) && !STRINGP (help))
2079 {
2080 if (FUNCTIONP (help))
2081 {
2082 Lisp_Object args[4];
2083 args[0] = help;
2084 args[1] = window;
2085 args[2] = object;
2086 args[3] = pos;
2087 help = safe_call (4, args);
2088 }
2089 else
2090 help = safe_eval (help);
2091
2092 if (!STRINGP (help))
2093 return;
2094 }
2095
2096 if (STRINGP (help) || NILP (help))
2097 {
2098 if (!NILP (Vshow_help_function))
2099 call1 (Vshow_help_function, help);
2100 else if (/* Don't overwrite minibuffer contents. */
2101 !MINI_WINDOW_P (XWINDOW (selected_window))
2102 /* Don't overwrite a keystroke echo. */
2103 && (NILP (echo_message_buffer)
2104 || ok_to_overwrite_keystroke_echo)
2105 /* Don't overwrite a prompt. */
2106 && !cursor_in_echo_area)
2107 {
2108 if (STRINGP (help))
2109 {
2110 int count = SPECPDL_INDEX ();
2111
2112 if (!help_echo_showing_p)
2113 Vpre_help_message = current_message ();
2114
2115 specbind (Qmessage_truncate_lines, Qt);
2116 message3_nolog (help, SBYTES (help),
2117 STRING_MULTIBYTE (help));
2118 unbind_to (count, Qnil);
2119 }
2120 else if (STRINGP (Vpre_help_message))
2121 {
2122 message3_nolog (Vpre_help_message,
2123 SBYTES (Vpre_help_message),
2124 STRING_MULTIBYTE (Vpre_help_message));
2125 Vpre_help_message = Qnil;
2126 }
2127 else
2128 message (0);
2129 }
2130
2131 help_echo_showing_p = STRINGP (help);
2132 }
2133 }
2134
2135
2136 \f
2137 /* Input of single characters from keyboard */
2138
2139 Lisp_Object print_help ();
2140 static Lisp_Object kbd_buffer_get_event ();
2141 static void record_char ();
2142
2143 #ifdef MULTI_KBOARD
2144 static jmp_buf wrong_kboard_jmpbuf;
2145 #endif
2146
2147 #define STOP_POLLING \
2148 do { if (! polling_stopped_here) stop_polling (); \
2149 polling_stopped_here = 1; } while (0)
2150
2151 #define RESUME_POLLING \
2152 do { if (polling_stopped_here) start_polling (); \
2153 polling_stopped_here = 0; } while (0)
2154
2155 /* read a character from the keyboard; call the redisplay if needed */
2156 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2157 -1 means do not do redisplay, but do do autosaving.
2158 1 means do both. */
2159
2160 /* The arguments MAPS and NMAPS are for menu prompting.
2161 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2162
2163 PREV_EVENT is the previous input event, or nil if we are reading
2164 the first event of a key sequence (or not reading a key sequence).
2165 If PREV_EVENT is t, that is a "magic" value that says
2166 not to run input methods, but in other respects to act as if
2167 not reading a key sequence.
2168
2169 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2170 if we used a mouse menu to read the input, or zero otherwise. If
2171 USED_MOUSE_MENU is null, we don't dereference it.
2172
2173 Value is t if we showed a menu and the user rejected it. */
2174
2175 Lisp_Object
2176 read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
2177 int commandflag;
2178 int nmaps;
2179 Lisp_Object *maps;
2180 Lisp_Object prev_event;
2181 int *used_mouse_menu;
2182 {
2183 volatile Lisp_Object c;
2184 int count;
2185 jmp_buf local_getcjmp;
2186 jmp_buf save_jump;
2187 volatile int key_already_recorded = 0;
2188 Lisp_Object tem, save;
2189 volatile Lisp_Object previous_echo_area_message;
2190 volatile Lisp_Object also_record;
2191 volatile int reread;
2192 struct gcpro gcpro1, gcpro2;
2193 EMACS_TIME last_idle_start;
2194 int polling_stopped_here = 0;
2195
2196 also_record = Qnil;
2197
2198 before_command_key_count = this_command_key_count;
2199 before_command_echo_length = echo_length ();
2200 c = Qnil;
2201 previous_echo_area_message = Qnil;
2202
2203 GCPRO2 (c, previous_echo_area_message);
2204
2205 retry:
2206
2207 reread = 0;
2208 if (CONSP (Vunread_post_input_method_events))
2209 {
2210 c = XCAR (Vunread_post_input_method_events);
2211 Vunread_post_input_method_events
2212 = XCDR (Vunread_post_input_method_events);
2213
2214 /* Undo what read_char_x_menu_prompt did when it unread
2215 additional keys returned by Fx_popup_menu. */
2216 if (CONSP (c)
2217 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2218 && NILP (XCDR (c)))
2219 c = XCAR (c);
2220
2221 reread = 1;
2222 goto reread_first;
2223 }
2224
2225 if (unread_command_char != -1)
2226 {
2227 XSETINT (c, unread_command_char);
2228 unread_command_char = -1;
2229
2230 reread = 1;
2231 goto reread_first;
2232 }
2233
2234 if (CONSP (Vunread_command_events))
2235 {
2236 c = XCAR (Vunread_command_events);
2237 Vunread_command_events = XCDR (Vunread_command_events);
2238
2239 /* Undo what read_char_x_menu_prompt did when it unread
2240 additional keys returned by Fx_popup_menu. */
2241 if (CONSP (c)
2242 && EQ (XCDR (c), Qdisabled)
2243 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c))))
2244 c = XCAR (c);
2245
2246 /* If the queued event is something that used the mouse,
2247 set used_mouse_menu accordingly. */
2248 if (used_mouse_menu
2249 && (EQ (c, Qtool_bar) || EQ (c, Qmenu_bar)))
2250 *used_mouse_menu = 1;
2251
2252 reread = 1;
2253 goto reread_for_input_method;
2254 }
2255
2256 if (CONSP (Vunread_input_method_events))
2257 {
2258 c = XCAR (Vunread_input_method_events);
2259 Vunread_input_method_events = XCDR (Vunread_input_method_events);
2260
2261 /* Undo what read_char_x_menu_prompt did when it unread
2262 additional keys returned by Fx_popup_menu. */
2263 if (CONSP (c)
2264 && (SYMBOLP (XCAR (c)) || INTEGERP (XCAR (c)))
2265 && NILP (XCDR (c)))
2266 c = XCAR (c);
2267 reread = 1;
2268 goto reread_for_input_method;
2269 }
2270
2271 /* If there is no function key translated before
2272 reset-this-command-lengths takes effect, forget about it. */
2273 before_command_restore_flag = 0;
2274
2275 if (!NILP (Vexecuting_macro))
2276 {
2277 /* We set this to Qmacro; since that's not a frame, nobody will
2278 try to switch frames on us, and the selected window will
2279 remain unchanged.
2280
2281 Since this event came from a macro, it would be misleading to
2282 leave internal_last_event_frame set to wherever the last
2283 real event came from. Normally, a switch-frame event selects
2284 internal_last_event_frame after each command is read, but
2285 events read from a macro should never cause a new frame to be
2286 selected. */
2287 Vlast_event_frame = internal_last_event_frame = Qmacro;
2288
2289 /* Exit the macro if we are at the end.
2290 Also, some things replace the macro with t
2291 to force an early exit. */
2292 if (EQ (Vexecuting_macro, Qt)
2293 || executing_macro_index >= XFASTINT (Flength (Vexecuting_macro)))
2294 {
2295 XSETINT (c, -1);
2296 goto exit;
2297 }
2298
2299 c = Faref (Vexecuting_macro, make_number (executing_macro_index));
2300 if (STRINGP (Vexecuting_macro)
2301 && (XINT (c) & 0x80))
2302 XSETFASTINT (c, CHAR_META | (XINT (c) & ~0x80));
2303
2304 executing_macro_index++;
2305
2306 goto from_macro;
2307 }
2308
2309 if (!NILP (unread_switch_frame))
2310 {
2311 c = unread_switch_frame;
2312 unread_switch_frame = Qnil;
2313
2314 /* This event should make it into this_command_keys, and get echoed
2315 again, so we do not set `reread'. */
2316 goto reread_first;
2317 }
2318
2319 /* if redisplay was requested */
2320 if (commandflag >= 0)
2321 {
2322 /* If there is pending input, process any events which are not
2323 user-visible, such as X selection_request events. */
2324 if (input_pending
2325 || detect_input_pending_run_timers (0))
2326 swallow_events (0); /* may clear input_pending */
2327
2328 /* Redisplay if no pending input. */
2329 while (!input_pending)
2330 {
2331 if (help_echo_showing_p && !EQ (selected_window, minibuf_window))
2332 redisplay_preserve_echo_area (5);
2333 else
2334 redisplay ();
2335
2336 if (!input_pending)
2337 /* Normal case: no input arrived during redisplay. */
2338 break;
2339
2340 /* Input arrived and pre-empted redisplay.
2341 Process any events which are not user-visible. */
2342 swallow_events (0);
2343 /* If that cleared input_pending, try again to redisplay. */
2344 }
2345 }
2346
2347 /* Message turns off echoing unless more keystrokes turn it on again.
2348
2349 The code in 20.x for the condition was
2350
2351 1. echo_area_glyphs && *echo_area_glyphs
2352 2. && echo_area_glyphs != current_kboard->echobuf
2353 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2354
2355 (1) means there's a current message displayed
2356
2357 (2) means it's not the message from echoing from the current
2358 kboard.
2359
2360 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2361 is set to a non-null value. This is done in read_char and it is
2362 set to echo_area_glyphs after a call to echo_char. That means
2363 ok_to_echo_at_next_pause is either null or
2364 current_kboard->echobuf with the appropriate current_kboard at
2365 that time.
2366
2367 So, condition (3) means in clear text ok_to_echo_at_next_pause
2368 must be either null, or the current message isn't from echoing at
2369 all, or it's from echoing from a different kboard than the
2370 current one. */
2371
2372 if (/* There currently is something in the echo area. */
2373 !NILP (echo_area_buffer[0])
2374 && (/* And it's either not from echoing. */
2375 !EQ (echo_area_buffer[0], echo_message_buffer)
2376 /* Or it's an echo from a different kboard. */
2377 || echo_kboard != current_kboard
2378 /* Or we explicitly allow overwriting whatever there is. */
2379 || ok_to_echo_at_next_pause == NULL))
2380 cancel_echoing ();
2381 else
2382 echo_dash ();
2383
2384 /* Try reading a character via menu prompting in the minibuf.
2385 Try this before the sit-for, because the sit-for
2386 would do the wrong thing if we are supposed to do
2387 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2388 after a mouse event so don't try a minibuf menu. */
2389 c = Qnil;
2390 if (nmaps > 0 && INTERACTIVE
2391 && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
2392 /* Don't bring up a menu if we already have another event. */
2393 && NILP (Vunread_command_events)
2394 && unread_command_char < 0
2395 && !detect_input_pending_run_timers (0))
2396 {
2397 c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
2398 if (! NILP (c))
2399 {
2400 key_already_recorded = 1;
2401 goto non_reread_1;
2402 }
2403 }
2404
2405 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2406 We will do that below, temporarily for short sections of code,
2407 when appropriate. local_getcjmp must be in effect
2408 around any call to sit_for or kbd_buffer_get_event;
2409 it *must not* be in effect when we call redisplay. */
2410
2411 if (_setjmp (local_getcjmp))
2412 {
2413 XSETINT (c, quit_char);
2414 internal_last_event_frame = selected_frame;
2415 Vlast_event_frame = internal_last_event_frame;
2416 /* If we report the quit char as an event,
2417 don't do so more than once. */
2418 if (!NILP (Vinhibit_quit))
2419 Vquit_flag = Qnil;
2420
2421 #ifdef MULTI_KBOARD
2422 {
2423 KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
2424 if (kb != current_kboard)
2425 {
2426 Lisp_Object link = kb->kbd_queue;
2427 /* We shouldn't get here if we were in single-kboard mode! */
2428 if (single_kboard)
2429 abort ();
2430 if (CONSP (link))
2431 {
2432 while (CONSP (XCDR (link)))
2433 link = XCDR (link);
2434 if (!NILP (XCDR (link)))
2435 abort ();
2436 }
2437 if (!CONSP (link))
2438 kb->kbd_queue = Fcons (c, Qnil);
2439 else
2440 XSETCDR (link, Fcons (c, Qnil));
2441 kb->kbd_queue_has_data = 1;
2442 current_kboard = kb;
2443 /* This is going to exit from read_char
2444 so we had better get rid of this frame's stuff. */
2445 UNGCPRO;
2446 longjmp (wrong_kboard_jmpbuf, 1);
2447 }
2448 }
2449 #endif
2450 goto non_reread;
2451 }
2452
2453 timer_start_idle ();
2454
2455 /* If in middle of key sequence and minibuffer not active,
2456 start echoing if enough time elapses. */
2457
2458 if (minibuf_level == 0
2459 && !current_kboard->immediate_echo
2460 && this_command_key_count > 0
2461 && ! noninteractive
2462 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2463 && NILP (Fzerop (Vecho_keystrokes))
2464 && (/* No message. */
2465 NILP (echo_area_buffer[0])
2466 /* Or empty message. */
2467 || (BUF_BEG (XBUFFER (echo_area_buffer[0]))
2468 == BUF_Z (XBUFFER (echo_area_buffer[0])))
2469 /* Or already echoing from same kboard. */
2470 || (echo_kboard && ok_to_echo_at_next_pause == echo_kboard)
2471 /* Or not echoing before and echoing allowed. */
2472 || (!echo_kboard && ok_to_echo_at_next_pause)))
2473 {
2474 Lisp_Object tem0;
2475
2476 /* After a mouse event, start echoing right away.
2477 This is because we are probably about to display a menu,
2478 and we don't want to delay before doing so. */
2479 if (EVENT_HAS_PARAMETERS (prev_event))
2480 echo_now ();
2481 else
2482 {
2483 int sec, usec;
2484 double duration = extract_float (Vecho_keystrokes);
2485 sec = (int) duration;
2486 usec = (duration - sec) * 1000000;
2487 save_getcjmp (save_jump);
2488 restore_getcjmp (local_getcjmp);
2489 tem0 = sit_for (sec, usec, 1, 1, 0);
2490 restore_getcjmp (save_jump);
2491 if (EQ (tem0, Qt)
2492 && ! CONSP (Vunread_command_events))
2493 echo_now ();
2494 }
2495 }
2496
2497 /* Maybe auto save due to number of keystrokes. */
2498
2499 if (commandflag != 0
2500 && auto_save_interval > 0
2501 && num_nonmacro_input_events - last_auto_save > max (auto_save_interval, 20)
2502 && !detect_input_pending_run_timers (0))
2503 {
2504 Fdo_auto_save (Qnil, Qnil);
2505 /* Hooks can actually change some buffers in auto save. */
2506 redisplay ();
2507 }
2508
2509 /* Try reading using an X menu.
2510 This is never confused with reading using the minibuf
2511 because the recursive call of read_char in read_char_minibuf_menu_prompt
2512 does not pass on any keymaps. */
2513
2514 if (nmaps > 0 && INTERACTIVE
2515 && !NILP (prev_event)
2516 && EVENT_HAS_PARAMETERS (prev_event)
2517 && !EQ (XCAR (prev_event), Qmenu_bar)
2518 && !EQ (XCAR (prev_event), Qtool_bar)
2519 /* Don't bring up a menu if we already have another event. */
2520 && NILP (Vunread_command_events)
2521 && unread_command_char < 0)
2522 {
2523 c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
2524
2525 /* Now that we have read an event, Emacs is not idle. */
2526 timer_stop_idle ();
2527
2528 goto exit;
2529 }
2530
2531 /* Maybe autosave and/or garbage collect due to idleness. */
2532
2533 if (INTERACTIVE && NILP (c))
2534 {
2535 int delay_level, buffer_size;
2536
2537 /* Slow down auto saves logarithmically in size of current buffer,
2538 and garbage collect while we're at it. */
2539 if (! MINI_WINDOW_P (XWINDOW (selected_window)))
2540 last_non_minibuf_size = Z - BEG;
2541 buffer_size = (last_non_minibuf_size >> 8) + 1;
2542 delay_level = 0;
2543 while (buffer_size > 64)
2544 delay_level++, buffer_size -= buffer_size >> 2;
2545 if (delay_level < 4) delay_level = 4;
2546 /* delay_level is 4 for files under around 50k, 7 at 100k,
2547 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2548
2549 /* Auto save if enough time goes by without input. */
2550 if (commandflag != 0
2551 && num_nonmacro_input_events > last_auto_save
2552 && INTEGERP (Vauto_save_timeout)
2553 && XINT (Vauto_save_timeout) > 0)
2554 {
2555 Lisp_Object tem0;
2556
2557 save_getcjmp (save_jump);
2558 restore_getcjmp (local_getcjmp);
2559 tem0 = sit_for (delay_level * XFASTINT (Vauto_save_timeout) / 4,
2560 0, 1, 1, 0);
2561 restore_getcjmp (save_jump);
2562
2563 if (EQ (tem0, Qt)
2564 && ! CONSP (Vunread_command_events))
2565 {
2566 Fdo_auto_save (Qnil, Qnil);
2567
2568 /* If we have auto-saved and there is still no input
2569 available, garbage collect if there has been enough
2570 consing going on to make it worthwhile. */
2571 if (!detect_input_pending_run_timers (0)
2572 && consing_since_gc > gc_cons_threshold / 2)
2573 Fgarbage_collect ();
2574
2575 redisplay ();
2576 }
2577 }
2578 }
2579
2580 /* If this has become non-nil here, it has been set by a timer
2581 or sentinel or filter. */
2582 if (CONSP (Vunread_command_events))
2583 {
2584 c = XCAR (Vunread_command_events);
2585 Vunread_command_events = XCDR (Vunread_command_events);
2586 }
2587
2588 /* Read something from current KBOARD's side queue, if possible. */
2589
2590 if (NILP (c))
2591 {
2592 if (current_kboard->kbd_queue_has_data)
2593 {
2594 if (!CONSP (current_kboard->kbd_queue))
2595 abort ();
2596 c = XCAR (current_kboard->kbd_queue);
2597 current_kboard->kbd_queue
2598 = XCDR (current_kboard->kbd_queue);
2599 if (NILP (current_kboard->kbd_queue))
2600 current_kboard->kbd_queue_has_data = 0;
2601 input_pending = readable_events (0);
2602 if (EVENT_HAS_PARAMETERS (c)
2603 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qswitch_frame))
2604 internal_last_event_frame = XCAR (XCDR (c));
2605 Vlast_event_frame = internal_last_event_frame;
2606 }
2607 }
2608
2609 #ifdef MULTI_KBOARD
2610 /* If current_kboard's side queue is empty check the other kboards.
2611 If one of them has data that we have not yet seen here,
2612 switch to it and process the data waiting for it.
2613
2614 Note: if the events queued up for another kboard
2615 have already been seen here, and therefore are not a complete command,
2616 the kbd_queue_has_data field is 0, so we skip that kboard here.
2617 That's to avoid an infinite loop switching between kboards here. */
2618 if (NILP (c) && !single_kboard)
2619 {
2620 KBOARD *kb;
2621 for (kb = all_kboards; kb; kb = kb->next_kboard)
2622 if (kb->kbd_queue_has_data)
2623 {
2624 current_kboard = kb;
2625 /* This is going to exit from read_char
2626 so we had better get rid of this frame's stuff. */
2627 UNGCPRO;
2628 longjmp (wrong_kboard_jmpbuf, 1);
2629 }
2630 }
2631 #endif
2632
2633 wrong_kboard:
2634
2635 STOP_POLLING;
2636
2637 /* Finally, we read from the main queue,
2638 and if that gives us something we can't use yet, we put it on the
2639 appropriate side queue and try again. */
2640
2641 if (NILP (c))
2642 {
2643 KBOARD *kb;
2644
2645 /* Actually read a character, waiting if necessary. */
2646 save_getcjmp (save_jump);
2647 restore_getcjmp (local_getcjmp);
2648 timer_start_idle ();
2649 c = kbd_buffer_get_event (&kb, used_mouse_menu);
2650 restore_getcjmp (save_jump);
2651
2652 #ifdef MULTI_KBOARD
2653 if (! NILP (c) && (kb != current_kboard))
2654 {
2655 Lisp_Object link = kb->kbd_queue;
2656 if (CONSP (link))
2657 {
2658 while (CONSP (XCDR (link)))
2659 link = XCDR (link);
2660 if (!NILP (XCDR (link)))
2661 abort ();
2662 }
2663 if (!CONSP (link))
2664 kb->kbd_queue = Fcons (c, Qnil);
2665 else
2666 XSETCDR (link, Fcons (c, Qnil));
2667 kb->kbd_queue_has_data = 1;
2668 c = Qnil;
2669 if (single_kboard)
2670 goto wrong_kboard;
2671 current_kboard = kb;
2672 /* This is going to exit from read_char
2673 so we had better get rid of this frame's stuff. */
2674 UNGCPRO;
2675 longjmp (wrong_kboard_jmpbuf, 1);
2676 }
2677 #endif
2678 }
2679
2680 /* Terminate Emacs in batch mode if at eof. */
2681 if (noninteractive && INTEGERP (c) && XINT (c) < 0)
2682 Fkill_emacs (make_number (1));
2683
2684 if (INTEGERP (c))
2685 {
2686 /* Add in any extra modifiers, where appropriate. */
2687 if ((extra_keyboard_modifiers & CHAR_CTL)
2688 || ((extra_keyboard_modifiers & 0177) < ' '
2689 && (extra_keyboard_modifiers & 0177) != 0))
2690 XSETINT (c, make_ctrl_char (XINT (c)));
2691
2692 /* Transfer any other modifier bits directly from
2693 extra_keyboard_modifiers to c. Ignore the actual character code
2694 in the low 16 bits of extra_keyboard_modifiers. */
2695 XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
2696 }
2697
2698 non_reread:
2699
2700 /* Record the last idle start time so that we can reset it
2701 should the next event read be a help-echo. */
2702 last_idle_start = timer_idleness_start_time;
2703 timer_stop_idle ();
2704 RESUME_POLLING;
2705
2706 if (NILP (c))
2707 {
2708 if (commandflag >= 0
2709 && !input_pending && !detect_input_pending_run_timers (0))
2710 redisplay ();
2711
2712 goto wrong_kboard;
2713 }
2714
2715 non_reread_1:
2716
2717 /* Buffer switch events are only for internal wakeups
2718 so don't show them to the user.
2719 Also, don't record a key if we already did. */
2720 if (BUFFERP (c) || key_already_recorded)
2721 goto exit;
2722
2723 /* Process special events within read_char
2724 and loop around to read another event. */
2725 save = Vquit_flag;
2726 Vquit_flag = Qnil;
2727 tem = access_keymap (get_keymap (Vspecial_event_map, 0, 1), c, 0, 0, 1);
2728 Vquit_flag = save;
2729
2730 if (!NILP (tem))
2731 {
2732 int was_locked = single_kboard;
2733
2734 last_input_char = c;
2735 Fcommand_execute (tem, Qnil, Fvector (1, &last_input_char), Qt);
2736
2737 if (CONSP (c) && EQ (XCAR (c), Qselect_window))
2738 /* We stopped being idle for this event; undo that. This
2739 prevents automatic window selection (under
2740 mouse_autoselect_window from acting as a real input event, for
2741 example banishing the mouse under mouse-avoidance-mode. */
2742 timer_idleness_start_time = last_idle_start;
2743
2744 /* Resume allowing input from any kboard, if that was true before. */
2745 if (!was_locked)
2746 any_kboard_state ();
2747
2748 goto retry;
2749 }
2750
2751 /* Handle things that only apply to characters. */
2752 if (INTEGERP (c))
2753 {
2754 /* If kbd_buffer_get_event gave us an EOF, return that. */
2755 if (XINT (c) == -1)
2756 goto exit;
2757
2758 if ((STRINGP (Vkeyboard_translate_table)
2759 && SCHARS (Vkeyboard_translate_table) > (unsigned) XFASTINT (c))
2760 || (VECTORP (Vkeyboard_translate_table)
2761 && XVECTOR (Vkeyboard_translate_table)->size > (unsigned) XFASTINT (c))
2762 || (CHAR_TABLE_P (Vkeyboard_translate_table)
2763 && CHAR_TABLE_ORDINARY_SLOTS > (unsigned) XFASTINT (c)))
2764 {
2765 Lisp_Object d;
2766 d = Faref (Vkeyboard_translate_table, c);
2767 /* nil in keyboard-translate-table means no translation. */
2768 if (!NILP (d))
2769 c = d;
2770 }
2771 }
2772
2773 /* If this event is a mouse click in the menu bar,
2774 return just menu-bar for now. Modify the mouse click event
2775 so we won't do this twice, then queue it up. */
2776 if (EVENT_HAS_PARAMETERS (c)
2777 && CONSP (XCDR (c))
2778 && CONSP (EVENT_START (c))
2779 && CONSP (XCDR (EVENT_START (c))))
2780 {
2781 Lisp_Object posn;
2782
2783 posn = POSN_BUFFER_POSN (EVENT_START (c));
2784 /* Handle menu-bar events:
2785 insert the dummy prefix event `menu-bar'. */
2786 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
2787 {
2788 /* Change menu-bar to (menu-bar) as the event "position". */
2789 POSN_BUFFER_SET_POSN (EVENT_START (c), Fcons (posn, Qnil));
2790
2791 also_record = c;
2792 Vunread_command_events = Fcons (c, Vunread_command_events);
2793 c = posn;
2794 }
2795 }
2796
2797 /* Store these characters into recent_keys, the dribble file if any,
2798 and the keyboard macro being defined, if any. */
2799 record_char (c);
2800 if (! NILP (also_record))
2801 record_char (also_record);
2802
2803 /* Wipe the echo area.
2804 But first, if we are about to use an input method,
2805 save the echo area contents for it to refer to. */
2806 if (INTEGERP (c)
2807 && ! NILP (Vinput_method_function)
2808 && (unsigned) XINT (c) >= ' '
2809 && (unsigned) XINT (c) != 127
2810 && (unsigned) XINT (c) < 256)
2811 {
2812 previous_echo_area_message = Fcurrent_message ();
2813 Vinput_method_previous_message = previous_echo_area_message;
2814 }
2815
2816 /* Now wipe the echo area, except for help events which do their
2817 own stuff with the echo area. */
2818 if (!CONSP (c)
2819 || (!(EQ (Qhelp_echo, XCAR (c)))
2820 && !(EQ (Qswitch_frame, XCAR (c)))))
2821 {
2822 if (!NILP (echo_area_buffer[0]))
2823 safe_run_hooks (Qecho_area_clear_hook);
2824 clear_message (1, 0);
2825 }
2826
2827 reread_for_input_method:
2828 from_macro:
2829 /* Pass this to the input method, if appropriate. */
2830 if (INTEGERP (c)
2831 && ! NILP (Vinput_method_function)
2832 /* Don't run the input method within a key sequence,
2833 after the first event of the key sequence. */
2834 && NILP (prev_event)
2835 && (unsigned) XINT (c) >= ' '
2836 && (unsigned) XINT (c) != 127
2837 && (unsigned) XINT (c) < 256)
2838 {
2839 Lisp_Object keys;
2840 int key_count;
2841 struct gcpro gcpro1;
2842 int count = SPECPDL_INDEX ();
2843
2844 /* Save the echo status. */
2845 int saved_immediate_echo = current_kboard->immediate_echo;
2846 struct kboard *saved_ok_to_echo = ok_to_echo_at_next_pause;
2847 int saved_echo_after_prompt = current_kboard->echo_after_prompt;
2848
2849 if (before_command_restore_flag)
2850 {
2851 this_command_key_count = before_command_key_count_1;
2852 if (this_command_key_count < this_single_command_key_start)
2853 this_single_command_key_start = this_command_key_count;
2854 echo_truncate (before_command_echo_length_1);
2855 before_command_restore_flag = 0;
2856 }
2857
2858 /* Save the this_command_keys status. */
2859 key_count = this_command_key_count;
2860
2861 if (key_count > 0)
2862 keys = Fcopy_sequence (this_command_keys);
2863 else
2864 keys = Qnil;
2865 GCPRO1 (keys);
2866
2867 /* Clear out this_command_keys. */
2868 this_command_key_count = 0;
2869
2870 /* Now wipe the echo area. */
2871 if (!NILP (echo_area_buffer[0]))
2872 safe_run_hooks (Qecho_area_clear_hook);
2873 clear_message (1, 0);
2874 echo_truncate (0);
2875
2876 /* If we are not reading a key sequence,
2877 never use the echo area. */
2878 if (maps == 0)
2879 {
2880 specbind (Qinput_method_use_echo_area, Qt);
2881 }
2882
2883 /* Call the input method. */
2884 tem = call1 (Vinput_method_function, c);
2885
2886 tem = unbind_to (count, tem);
2887
2888 /* Restore the saved echoing state
2889 and this_command_keys state. */
2890 this_command_key_count = key_count;
2891 if (key_count > 0)
2892 this_command_keys = keys;
2893
2894 cancel_echoing ();
2895 ok_to_echo_at_next_pause = saved_ok_to_echo;
2896 current_kboard->echo_after_prompt = saved_echo_after_prompt;
2897 if (saved_immediate_echo)
2898 echo_now ();
2899
2900 UNGCPRO;
2901
2902 /* The input method can return no events. */
2903 if (! CONSP (tem))
2904 {
2905 /* Bring back the previous message, if any. */
2906 if (! NILP (previous_echo_area_message))
2907 message_with_string ("%s", previous_echo_area_message, 0);
2908 goto retry;
2909 }
2910 /* It returned one event or more. */
2911 c = XCAR (tem);
2912 Vunread_post_input_method_events
2913 = nconc2 (XCDR (tem), Vunread_post_input_method_events);
2914 }
2915
2916 reread_first:
2917
2918 /* Display help if not echoing. */
2919 if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
2920 {
2921 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
2922 Lisp_Object help, object, position, window, tem;
2923
2924 tem = Fcdr (XCDR (c));
2925 help = Fcar (tem);
2926 tem = Fcdr (tem);
2927 window = Fcar (tem);
2928 tem = Fcdr (tem);
2929 object = Fcar (tem);
2930 tem = Fcdr (tem);
2931 position = Fcar (tem);
2932
2933 show_help_echo (help, window, object, position, 0);
2934
2935 /* We stopped being idle for this event; undo that. */
2936 timer_idleness_start_time = last_idle_start;
2937 goto retry;
2938 }
2939
2940 if (this_command_key_count == 0 || ! reread)
2941 {
2942 before_command_key_count = this_command_key_count;
2943 before_command_echo_length = echo_length ();
2944
2945 /* Don't echo mouse motion events. */
2946 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
2947 && NILP (Fzerop (Vecho_keystrokes))
2948 && ! (EVENT_HAS_PARAMETERS (c)
2949 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
2950 {
2951 echo_char (c);
2952 if (! NILP (also_record))
2953 echo_char (also_record);
2954 /* Once we reread a character, echoing can happen
2955 the next time we pause to read a new one. */
2956 ok_to_echo_at_next_pause = current_kboard;
2957 }
2958
2959 /* Record this character as part of the current key. */
2960 add_command_key (c);
2961 if (! NILP (also_record))
2962 add_command_key (also_record);
2963 }
2964
2965 last_input_char = c;
2966 num_input_events++;
2967
2968 /* Process the help character specially if enabled */
2969 if (!NILP (Vhelp_form) && help_char_p (c))
2970 {
2971 Lisp_Object tem0;
2972 count = SPECPDL_INDEX ();
2973
2974 record_unwind_protect (Fset_window_configuration,
2975 Fcurrent_window_configuration (Qnil));
2976
2977 tem0 = Feval (Vhelp_form);
2978 if (STRINGP (tem0))
2979 internal_with_output_to_temp_buffer ("*Help*", print_help, tem0);
2980
2981 cancel_echoing ();
2982 do
2983 c = read_char (0, 0, 0, Qnil, 0);
2984 while (BUFFERP (c));
2985 /* Remove the help from the frame */
2986 unbind_to (count, Qnil);
2987
2988 redisplay ();
2989 if (EQ (c, make_number (040)))
2990 {
2991 cancel_echoing ();
2992 do
2993 c = read_char (0, 0, 0, Qnil, 0);
2994 while (BUFFERP (c));
2995 }
2996 }
2997
2998 exit:
2999 RESUME_POLLING;
3000 RETURN_UNGCPRO (c);
3001 }
3002
3003 /* Record a key that came from a mouse menu.
3004 Record it for echoing, for this-command-keys, and so on. */
3005
3006 static void
3007 record_menu_key (c)
3008 Lisp_Object c;
3009 {
3010 /* Wipe the echo area. */
3011 clear_message (1, 0);
3012
3013 record_char (c);
3014
3015 before_command_key_count = this_command_key_count;
3016 before_command_echo_length = echo_length ();
3017
3018 /* Don't echo mouse motion events. */
3019 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
3020 && NILP (Fzerop (Vecho_keystrokes)))
3021 {
3022 echo_char (c);
3023
3024 /* Once we reread a character, echoing can happen
3025 the next time we pause to read a new one. */
3026 ok_to_echo_at_next_pause = 0;
3027 }
3028
3029 /* Record this character as part of the current key. */
3030 add_command_key (c);
3031
3032 /* Re-reading in the middle of a command */
3033 last_input_char = c;
3034 num_input_events++;
3035 }
3036
3037 /* Return 1 if should recognize C as "the help character". */
3038
3039 int
3040 help_char_p (c)
3041 Lisp_Object c;
3042 {
3043 Lisp_Object tail;
3044
3045 if (EQ (c, Vhelp_char))
3046 return 1;
3047 for (tail = Vhelp_event_list; CONSP (tail); tail = XCDR (tail))
3048 if (EQ (c, XCAR (tail)))
3049 return 1;
3050 return 0;
3051 }
3052
3053 /* Record the input event C in various ways. */
3054
3055 static void
3056 record_char (c)
3057 Lisp_Object c;
3058 {
3059 int recorded = 0;
3060
3061 if (CONSP (c) && (EQ (XCAR (c), Qhelp_echo) || EQ (XCAR (c), Qmouse_movement)))
3062 {
3063 /* To avoid filling recent_keys with help-echo and mouse-movement
3064 events, we filter out repeated help-echo events, only store the
3065 first and last in a series of mouse-movement events, and don't
3066 store repeated help-echo events which are only separated by
3067 mouse-movement events. */
3068
3069 Lisp_Object ev1, ev2, ev3;
3070 int ix1, ix2, ix3;
3071
3072 if ((ix1 = recent_keys_index - 1) < 0)
3073 ix1 = NUM_RECENT_KEYS - 1;
3074 ev1 = AREF (recent_keys, ix1);
3075
3076 if ((ix2 = ix1 - 1) < 0)
3077 ix2 = NUM_RECENT_KEYS - 1;
3078 ev2 = AREF (recent_keys, ix2);
3079
3080 if ((ix3 = ix2 - 1) < 0)
3081 ix3 = NUM_RECENT_KEYS - 1;
3082 ev3 = AREF (recent_keys, ix3);
3083
3084 if (EQ (XCAR (c), Qhelp_echo))
3085 {
3086 /* Don't record `help-echo' in recent_keys unless it shows some help
3087 message, and a different help than the previously recorded
3088 event. */
3089 Lisp_Object help, last_help;
3090
3091 help = Fcar_safe (Fcdr_safe (XCDR (c)));
3092 if (!STRINGP (help))
3093 recorded = 1;
3094 else if (CONSP (ev1) && EQ (XCAR (ev1), Qhelp_echo)
3095 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev1))), EQ (last_help, help)))
3096 recorded = 1;
3097 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3098 && CONSP (ev2) && EQ (XCAR (ev2), Qhelp_echo)
3099 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev2))), EQ (last_help, help)))
3100 recorded = -1;
3101 else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3102 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3103 && CONSP (ev3) && EQ (XCAR (ev3), Qhelp_echo)
3104 && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev3))), EQ (last_help, help)))
3105 recorded = -2;
3106 }
3107 else if (EQ (XCAR (c), Qmouse_movement))
3108 {
3109 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3110 So additional mouse movement events replace the last element. */
3111 Lisp_Object last_window, window;
3112
3113 window = Fcar_safe (Fcar_safe (XCDR (c)));
3114 if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
3115 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev1))), EQ (last_window, window))
3116 && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
3117 && (last_window = Fcar_safe (Fcar_safe (XCDR (ev2))), EQ (last_window, window)))
3118 {
3119 ASET (recent_keys, ix1, c);
3120 recorded = 1;
3121 }
3122 }
3123 }
3124 else
3125 store_kbd_macro_char (c);
3126
3127 if (!recorded)
3128 {
3129 total_keys++;
3130 ASET (recent_keys, recent_keys_index, c);
3131 if (++recent_keys_index >= NUM_RECENT_KEYS)
3132 recent_keys_index = 0;
3133 }
3134 else if (recorded < 0)
3135 {
3136 /* We need to remove one or two events from recent_keys.
3137 To do this, we simply put nil at those events and move the
3138 recent_keys_index backwards over those events. Usually,
3139 users will never see those nil events, as they will be
3140 overwritten by the command keys entered to see recent_keys
3141 (e.g. C-h l). */
3142
3143 while (recorded++ < 0 && total_keys > 0)
3144 {
3145 if (total_keys < NUM_RECENT_KEYS)
3146 total_keys--;
3147 if (--recent_keys_index < 0)
3148 recent_keys_index = NUM_RECENT_KEYS - 1;
3149 ASET (recent_keys, recent_keys_index, Qnil);
3150 }
3151 }
3152
3153 num_nonmacro_input_events++;
3154
3155 /* Write c to the dribble file. If c is a lispy event, write
3156 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3157 If you, dear reader, have a better idea, you've got the source. :-) */
3158 if (dribble)
3159 {
3160 if (INTEGERP (c))
3161 {
3162 if (XUINT (c) < 0x100)
3163 putc (XINT (c), dribble);
3164 else
3165 fprintf (dribble, " 0x%x", (int) XUINT (c));
3166 }
3167 else
3168 {
3169 Lisp_Object dribblee;
3170
3171 /* If it's a structured event, take the event header. */
3172 dribblee = EVENT_HEAD (c);
3173
3174 if (SYMBOLP (dribblee))
3175 {
3176 putc ('<', dribble);
3177 fwrite (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
3178 SBYTES (SYMBOL_NAME (dribblee)),
3179 dribble);
3180 putc ('>', dribble);
3181 }
3182 }
3183
3184 fflush (dribble);
3185 }
3186 }
3187
3188 Lisp_Object
3189 print_help (object)
3190 Lisp_Object object;
3191 {
3192 struct buffer *old = current_buffer;
3193 Fprinc (object, Qnil);
3194 set_buffer_internal (XBUFFER (Vstandard_output));
3195 call0 (intern ("help-mode"));
3196 set_buffer_internal (old);
3197 return Qnil;
3198 }
3199
3200 /* Copy out or in the info on where C-g should throw to.
3201 This is used when running Lisp code from within get_char,
3202 in case get_char is called recursively.
3203 See read_process_output. */
3204
3205 static void
3206 save_getcjmp (temp)
3207 jmp_buf temp;
3208 {
3209 bcopy (getcjmp, temp, sizeof getcjmp);
3210 }
3211
3212 static void
3213 restore_getcjmp (temp)
3214 jmp_buf temp;
3215 {
3216 bcopy (temp, getcjmp, sizeof getcjmp);
3217 }
3218 \f
3219 #ifdef HAVE_MOUSE
3220
3221 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
3222 of this function. */
3223
3224 static Lisp_Object
3225 tracking_off (old_value)
3226 Lisp_Object old_value;
3227 {
3228 do_mouse_tracking = old_value;
3229 if (NILP (old_value))
3230 {
3231 /* Redisplay may have been preempted because there was input
3232 available, and it assumes it will be called again after the
3233 input has been processed. If the only input available was
3234 the sort that we have just disabled, then we need to call
3235 redisplay. */
3236 if (!readable_events (1))
3237 {
3238 redisplay_preserve_echo_area (6);
3239 get_input_pending (&input_pending, 1);
3240 }
3241 }
3242 return Qnil;
3243 }
3244
3245 DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
3246 doc: /* Evaluate BODY with mouse movement events enabled.
3247 Within a `track-mouse' form, mouse motion generates input events that
3248 you can read with `read-event'.
3249 Normally, mouse motion is ignored.
3250 usage: (track-mouse BODY ...) */)
3251 (args)
3252 Lisp_Object args;
3253 {
3254 int count = SPECPDL_INDEX ();
3255 Lisp_Object val;
3256
3257 record_unwind_protect (tracking_off, do_mouse_tracking);
3258
3259 do_mouse_tracking = Qt;
3260
3261 val = Fprogn (args);
3262 return unbind_to (count, val);
3263 }
3264
3265 /* If mouse has moved on some frame, return one of those frames.
3266 Return 0 otherwise. */
3267
3268 static FRAME_PTR
3269 some_mouse_moved ()
3270 {
3271 Lisp_Object tail, frame;
3272
3273 FOR_EACH_FRAME (tail, frame)
3274 {
3275 if (XFRAME (frame)->mouse_moved)
3276 return XFRAME (frame);
3277 }
3278
3279 return 0;
3280 }
3281
3282 #endif /* HAVE_MOUSE */
3283 \f
3284 /* Low level keyboard/mouse input.
3285 kbd_buffer_store_event places events in kbd_buffer, and
3286 kbd_buffer_get_event retrieves them. */
3287
3288 /* Return true iff there are any events in the queue that read-char
3289 would return. If this returns false, a read-char would block. */
3290 static int
3291 readable_filtered_events (do_timers_now, filter_events)
3292 int do_timers_now;
3293 int filter_events;
3294 {
3295 if (do_timers_now)
3296 timer_check (do_timers_now);
3297
3298 /* If the buffer contains only FOCUS_IN_EVENT events,
3299 and FILTER_EVENTS is nonzero, report it as empty. */
3300 if (kbd_fetch_ptr != kbd_store_ptr)
3301 {
3302 int have_live_event = 1;
3303
3304 if (filter_events)
3305 {
3306 struct input_event *event;
3307
3308 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3309 ? kbd_fetch_ptr
3310 : kbd_buffer);
3311
3312 while (have_live_event && event->kind == FOCUS_IN_EVENT)
3313 {
3314 event++;
3315 if (event == kbd_buffer + KBD_BUFFER_SIZE)
3316 event = kbd_buffer;
3317 if (event == kbd_store_ptr)
3318 have_live_event = 0;
3319 }
3320 }
3321 if (have_live_event) return 1;
3322 }
3323
3324 #ifdef HAVE_MOUSE
3325 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3326 return 1;
3327 #endif
3328 if (single_kboard)
3329 {
3330 if (current_kboard->kbd_queue_has_data)
3331 return 1;
3332 }
3333 else
3334 {
3335 KBOARD *kb;
3336 for (kb = all_kboards; kb; kb = kb->next_kboard)
3337 if (kb->kbd_queue_has_data)
3338 return 1;
3339 }
3340 return 0;
3341 }
3342
3343 /* Return true iff there are any events in the queue that read-char
3344 would return. If this returns false, a read-char would block. */
3345 static int
3346 readable_events (do_timers_now)
3347 int do_timers_now;
3348 {
3349 return readable_filtered_events (do_timers_now, 0);
3350 }
3351
3352 /* Set this for debugging, to have a way to get out */
3353 int stop_character;
3354
3355 #ifdef MULTI_KBOARD
3356 static KBOARD *
3357 event_to_kboard (event)
3358 struct input_event *event;
3359 {
3360 Lisp_Object frame;
3361 frame = event->frame_or_window;
3362 if (CONSP (frame))
3363 frame = XCAR (frame);
3364 else if (WINDOWP (frame))
3365 frame = WINDOW_FRAME (XWINDOW (frame));
3366
3367 /* There are still some events that don't set this field.
3368 For now, just ignore the problem.
3369 Also ignore dead frames here. */
3370 if (!FRAMEP (frame) || !FRAME_LIVE_P (XFRAME (frame)))
3371 return 0;
3372 else
3373 return FRAME_KBOARD (XFRAME (frame));
3374 }
3375 #endif
3376
3377 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3378
3379 void
3380 kbd_buffer_store_event (event)
3381 register struct input_event *event;
3382 {
3383 if (event->kind == NO_EVENT)
3384 abort ();
3385
3386 if (event->kind == ASCII_KEYSTROKE_EVENT)
3387 {
3388 register int c = event->code & 0377;
3389
3390 if (event->modifiers & ctrl_modifier)
3391 c = make_ctrl_char (c);
3392
3393 c |= (event->modifiers
3394 & (meta_modifier | alt_modifier
3395 | hyper_modifier | super_modifier));
3396
3397 if (c == quit_char)
3398 {
3399 static SIGTYPE interrupt_signal P_ ((int));
3400 #ifdef MULTI_KBOARD
3401 KBOARD *kb;
3402 struct input_event *sp;
3403
3404 if (single_kboard
3405 && (kb = FRAME_KBOARD (XFRAME (event->frame_or_window)),
3406 kb != current_kboard))
3407 {
3408 kb->kbd_queue
3409 = Fcons (make_lispy_switch_frame (event->frame_or_window),
3410 Fcons (make_number (c), Qnil));
3411 kb->kbd_queue_has_data = 1;
3412 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3413 {
3414 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3415 sp = kbd_buffer;
3416
3417 if (event_to_kboard (sp) == kb)
3418 {
3419 sp->kind = NO_EVENT;
3420 sp->frame_or_window = Qnil;
3421 sp->arg = Qnil;
3422 }
3423 }
3424 return;
3425 }
3426 #endif
3427
3428 /* If this results in a quit_char being returned to Emacs as
3429 input, set Vlast_event_frame properly. If this doesn't
3430 get returned to Emacs as an event, the next event read
3431 will set Vlast_event_frame again, so this is safe to do. */
3432 {
3433 Lisp_Object focus;
3434
3435 focus = FRAME_FOCUS_FRAME (XFRAME (event->frame_or_window));
3436 if (NILP (focus))
3437 focus = event->frame_or_window;
3438 internal_last_event_frame = focus;
3439 Vlast_event_frame = focus;
3440 }
3441
3442 last_event_timestamp = event->timestamp;
3443 interrupt_signal (0 /* dummy */);
3444 return;
3445 }
3446
3447 if (c && c == stop_character)
3448 {
3449 sys_suspend ();
3450 return;
3451 }
3452 }
3453 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3454 Just ignore the second one. */
3455 else if (event->kind == BUFFER_SWITCH_EVENT
3456 && kbd_fetch_ptr != kbd_store_ptr
3457 && kbd_store_ptr->kind == BUFFER_SWITCH_EVENT)
3458 return;
3459
3460 if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
3461 kbd_store_ptr = kbd_buffer;
3462
3463 /* Don't let the very last slot in the buffer become full,
3464 since that would make the two pointers equal,
3465 and that is indistinguishable from an empty buffer.
3466 Discard the event if it would fill the last slot. */
3467 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
3468 {
3469 int idx;
3470
3471 #if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
3472 prone to assign individual members for other events, in case
3473 the input_event structure is changed. --2000-07-13, gerd. */
3474 struct input_event *sp = kbd_store_ptr;
3475 sp->kind = event->kind;
3476 if (event->kind == SELECTION_REQUEST_EVENT)
3477 {
3478 /* We must not use the ordinary copying code for this case,
3479 since `part' is an enum and copying it might not copy enough
3480 in this case. */
3481 bcopy (event, (char *) sp, sizeof (*event));
3482 }
3483 else
3484
3485 {
3486 sp->code = event->code;
3487 sp->part = event->part;
3488 sp->frame_or_window = event->frame_or_window;
3489 sp->arg = event->arg;
3490 sp->modifiers = event->modifiers;
3491 sp->x = event->x;
3492 sp->y = event->y;
3493 sp->timestamp = event->timestamp;
3494 }
3495 #else
3496 *kbd_store_ptr = *event;
3497 #endif
3498
3499 idx = 2 * (kbd_store_ptr - kbd_buffer);
3500 ASET (kbd_buffer_gcpro, idx, event->frame_or_window);
3501 ASET (kbd_buffer_gcpro, idx + 1, event->arg);
3502 ++kbd_store_ptr;
3503 }
3504 }
3505
3506
3507 /* Generate HELP_EVENT input_events in BUFP which has room for
3508 SIZE events. If there's not enough room in BUFP, ignore this
3509 event.
3510
3511 HELP is the help form.
3512
3513 FRAME is the frame on which the help is generated. OBJECT is the
3514 Lisp object where the help was found (a buffer, a string, an
3515 overlay, or nil if neither from a string nor from a buffer. POS is
3516 the position within OBJECT where the help was found.
3517
3518 Value is the number of input_events generated. */
3519
3520 int
3521 gen_help_event (bufp, size, help, frame, window, object, pos)
3522 struct input_event *bufp;
3523 int size;
3524 Lisp_Object help, frame, object, window;
3525 int pos;
3526 {
3527 if (size >= 1)
3528 {
3529 bufp->kind = HELP_EVENT;
3530 bufp->frame_or_window = frame;
3531 bufp->arg = object;
3532 bufp->x = WINDOWP (window) ? window : frame;
3533 bufp->y = help;
3534 bufp->code = pos;
3535 return 1;
3536 }
3537 return 0;
3538 }
3539
3540
3541 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3542
3543 void
3544 kbd_buffer_store_help_event (frame, help)
3545 Lisp_Object frame, help;
3546 {
3547 struct input_event event;
3548
3549 event.kind = HELP_EVENT;
3550 event.frame_or_window = frame;
3551 event.arg = Qnil;
3552 event.x = Qnil;
3553 event.y = help;
3554 event.code = 0;
3555 kbd_buffer_store_event (&event);
3556 }
3557
3558 \f
3559 /* Discard any mouse events in the event buffer by setting them to
3560 NO_EVENT. */
3561 void
3562 discard_mouse_events ()
3563 {
3564 struct input_event *sp;
3565 for (sp = kbd_fetch_ptr; sp != kbd_store_ptr; sp++)
3566 {
3567 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3568 sp = kbd_buffer;
3569
3570 if (sp->kind == MOUSE_CLICK_EVENT
3571 #ifdef WINDOWSNT
3572 || sp->kind == W32_SCROLL_BAR_CLICK_EVENT
3573 #endif
3574 || sp->kind == SCROLL_BAR_CLICK_EVENT)
3575 {
3576 sp->kind = NO_EVENT;
3577 }
3578 }
3579 }
3580
3581
3582 /* Return non-zero if there are any real events waiting in the event
3583 buffer, not counting `NO_EVENT's.
3584
3585 If DISCARD is non-zero, discard NO_EVENT events at the front of
3586 the input queue, possibly leaving the input queue empty if there
3587 are no real input events. */
3588
3589 int
3590 kbd_buffer_events_waiting (discard)
3591 int discard;
3592 {
3593 struct input_event *sp;
3594
3595 for (sp = kbd_fetch_ptr;
3596 sp != kbd_store_ptr && sp->kind == NO_EVENT;
3597 ++sp)
3598 {
3599 if (sp == kbd_buffer + KBD_BUFFER_SIZE)
3600 sp = kbd_buffer;
3601 }
3602
3603 if (discard)
3604 kbd_fetch_ptr = sp;
3605
3606 return sp != kbd_store_ptr && sp->kind != NO_EVENT;
3607 }
3608
3609 \f
3610 /* Clear input event EVENT. */
3611
3612 static INLINE void
3613 clear_event (event)
3614 struct input_event *event;
3615 {
3616 int idx = 2 * (event - kbd_buffer);
3617 ASET (kbd_buffer_gcpro, idx, Qnil);
3618 ASET (kbd_buffer_gcpro, idx + 1, Qnil);
3619 event->kind = NO_EVENT;
3620 }
3621
3622
3623 /* Read one event from the event buffer, waiting if necessary.
3624 The value is a Lisp object representing the event.
3625 The value is nil for an event that should be ignored,
3626 or that was handled here.
3627 We always read and discard one event. */
3628
3629 static Lisp_Object
3630 kbd_buffer_get_event (kbp, used_mouse_menu)
3631 KBOARD **kbp;
3632 int *used_mouse_menu;
3633 {
3634 register int c;
3635 Lisp_Object obj;
3636
3637 if (noninteractive)
3638 {
3639 c = getchar ();
3640 XSETINT (obj, c);
3641 *kbp = current_kboard;
3642 return obj;
3643 }
3644
3645 /* Wait until there is input available. */
3646 for (;;)
3647 {
3648 if (kbd_fetch_ptr != kbd_store_ptr)
3649 break;
3650 #ifdef HAVE_MOUSE
3651 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3652 break;
3653 #endif
3654
3655 /* If the quit flag is set, then read_char will return
3656 quit_char, so that counts as "available input." */
3657 if (!NILP (Vquit_flag))
3658 quit_throw_to_read_char ();
3659
3660 /* One way or another, wait until input is available; then, if
3661 interrupt handlers have not read it, read it now. */
3662
3663 #ifdef OLDVMS
3664 wait_for_kbd_input ();
3665 #else
3666 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3667 #ifdef SIGIO
3668 gobble_input (0);
3669 #endif /* SIGIO */
3670 if (kbd_fetch_ptr != kbd_store_ptr)
3671 break;
3672 #ifdef HAVE_MOUSE
3673 if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3674 break;
3675 #endif
3676 {
3677 Lisp_Object minus_one;
3678
3679 XSETINT (minus_one, -1);
3680 wait_reading_process_input (0, 0, minus_one, 1);
3681
3682 if (!interrupt_input && kbd_fetch_ptr == kbd_store_ptr)
3683 /* Pass 1 for EXPECT since we just waited to have input. */
3684 read_avail_input (1);
3685 }
3686 #endif /* not VMS */
3687 }
3688
3689 if (CONSP (Vunread_command_events))
3690 {
3691 Lisp_Object first;
3692 first = XCAR (Vunread_command_events);
3693 Vunread_command_events = XCDR (Vunread_command_events);
3694 *kbp = current_kboard;
3695 return first;
3696 }
3697
3698 /* At this point, we know that there is a readable event available
3699 somewhere. If the event queue is empty, then there must be a
3700 mouse movement enabled and available. */
3701 if (kbd_fetch_ptr != kbd_store_ptr)
3702 {
3703 struct input_event *event;
3704
3705 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3706 ? kbd_fetch_ptr
3707 : kbd_buffer);
3708
3709 last_event_timestamp = event->timestamp;
3710
3711 #ifdef MULTI_KBOARD
3712 *kbp = event_to_kboard (event);
3713 if (*kbp == 0)
3714 *kbp = current_kboard; /* Better than returning null ptr? */
3715 #else
3716 *kbp = &the_only_kboard;
3717 #endif
3718
3719 obj = Qnil;
3720
3721 /* These two kinds of events get special handling
3722 and don't actually appear to the command loop.
3723 We return nil for them. */
3724 if (event->kind == SELECTION_REQUEST_EVENT)
3725 {
3726 #ifdef HAVE_X11
3727 struct input_event copy;
3728
3729 /* Remove it from the buffer before processing it,
3730 since otherwise swallow_events will see it
3731 and process it again. */
3732 copy = *event;
3733 kbd_fetch_ptr = event + 1;
3734 input_pending = readable_events (0);
3735 x_handle_selection_request (&copy);
3736 #else
3737 /* We're getting selection request events, but we don't have
3738 a window system. */
3739 abort ();
3740 #endif
3741 }
3742
3743 else if (event->kind == SELECTION_CLEAR_EVENT)
3744 {
3745 #ifdef HAVE_X11
3746 struct input_event copy;
3747
3748 /* Remove it from the buffer before processing it. */
3749 copy = *event;
3750 kbd_fetch_ptr = event + 1;
3751 input_pending = readable_events (0);
3752 x_handle_selection_clear (&copy);
3753 #else
3754 /* We're getting selection request events, but we don't have
3755 a window system. */
3756 abort ();
3757 #endif
3758 }
3759 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
3760 else if (event->kind == DELETE_WINDOW_EVENT)
3761 {
3762 /* Make an event (delete-frame (FRAME)). */
3763 obj = Fcons (event->frame_or_window, Qnil);
3764 obj = Fcons (Qdelete_frame, Fcons (obj, Qnil));
3765 kbd_fetch_ptr = event + 1;
3766 }
3767 #endif
3768 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3769 else if (event->kind == ICONIFY_EVENT)
3770 {
3771 /* Make an event (iconify-frame (FRAME)). */
3772 obj = Fcons (event->frame_or_window, Qnil);
3773 obj = Fcons (Qiconify_frame, Fcons (obj, Qnil));
3774 kbd_fetch_ptr = event + 1;
3775 }
3776 else if (event->kind == DEICONIFY_EVENT)
3777 {
3778 /* Make an event (make-frame-visible (FRAME)). */
3779 obj = Fcons (event->frame_or_window, Qnil);
3780 obj = Fcons (Qmake_frame_visible, Fcons (obj, Qnil));
3781 kbd_fetch_ptr = event + 1;
3782 }
3783 #endif
3784 else if (event->kind == BUFFER_SWITCH_EVENT)
3785 {
3786 /* The value doesn't matter here; only the type is tested. */
3787 XSETBUFFER (obj, current_buffer);
3788 kbd_fetch_ptr = event + 1;
3789 }
3790 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
3791 else if (event->kind == MENU_BAR_ACTIVATE_EVENT)
3792 {
3793 kbd_fetch_ptr = event + 1;
3794 input_pending = readable_events (0);
3795 if (FRAME_LIVE_P (XFRAME (event->frame_or_window)))
3796 x_activate_menubar (XFRAME (event->frame_or_window));
3797 }
3798 #endif
3799 #ifdef WINDOWSNT
3800 else if (event->kind == LANGUAGE_CHANGE_EVENT)
3801 {
3802 /* Make an event (language-change (FRAME CHARSET LCID)). */
3803 obj = Fcons (event->modifiers, Qnil);
3804 obj = Fcons (event->code, obj);
3805 obj = Fcons (event->frame_or_window, obj);
3806 obj = Fcons (Qlanguage_change, Fcons (obj, Qnil));
3807 kbd_fetch_ptr = event + 1;
3808 }
3809 #endif
3810 else if (event->kind == SAVE_SESSION_EVENT)
3811 {
3812 obj = Fcons (Qsave_session, Qnil);
3813 kbd_fetch_ptr = event + 1;
3814 }
3815 /* Just discard these, by returning nil.
3816 With MULTI_KBOARD, these events are used as placeholders
3817 when we need to randomly delete events from the queue.
3818 (They shouldn't otherwise be found in the buffer,
3819 but on some machines it appears they do show up
3820 even without MULTI_KBOARD.) */
3821 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3822 mouse events during a popup-menu call. */
3823 else if (event->kind == NO_EVENT)
3824 kbd_fetch_ptr = event + 1;
3825 else if (event->kind == HELP_EVENT)
3826 {
3827 Lisp_Object object, position, help, frame, window;
3828
3829 frame = event->frame_or_window;
3830 object = event->arg;
3831 position = make_number (event->code);
3832 window = event->x;
3833 help = event->y;
3834 clear_event (event);
3835
3836 kbd_fetch_ptr = event + 1;
3837 if (!WINDOWP (window))
3838 window = Qnil;
3839 obj = Fcons (Qhelp_echo,
3840 list5 (frame, help, window, object, position));
3841 }
3842 else if (event->kind == FOCUS_IN_EVENT)
3843 {
3844 /* Notification of a FocusIn event. The frame receiving the
3845 focus is in event->frame_or_window. Generate a
3846 switch-frame event if necessary. */
3847 Lisp_Object frame, focus;
3848
3849 frame = event->frame_or_window;
3850 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
3851 if (FRAMEP (focus))
3852 frame = focus;
3853
3854 if (!EQ (frame, internal_last_event_frame)
3855 && !EQ (frame, selected_frame))
3856 obj = make_lispy_switch_frame (frame);
3857 internal_last_event_frame = frame;
3858 kbd_fetch_ptr = event + 1;
3859 }
3860 else if (event->kind == SELECT_WINDOW_EVENT)
3861 {
3862 /* Make an event (select-window (WINDOW)). */
3863 obj = Fcons (event->frame_or_window, Qnil);
3864 obj = Fcons (Qselect_window, Fcons (obj, Qnil));
3865
3866 kbd_fetch_ptr = event + 1;
3867 }
3868 else
3869 {
3870 /* If this event is on a different frame, return a switch-frame this
3871 time, and leave the event in the queue for next time. */
3872 Lisp_Object frame;
3873 Lisp_Object focus;
3874
3875 frame = event->frame_or_window;
3876 if (CONSP (frame))
3877 frame = XCAR (frame);
3878 else if (WINDOWP (frame))
3879 frame = WINDOW_FRAME (XWINDOW (frame));
3880
3881 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
3882 if (! NILP (focus))
3883 frame = focus;
3884
3885 if (! EQ (frame, internal_last_event_frame)
3886 && !EQ (frame, selected_frame))
3887 obj = make_lispy_switch_frame (frame);
3888 internal_last_event_frame = frame;
3889
3890 /* If we didn't decide to make a switch-frame event, go ahead
3891 and build a real event from the queue entry. */
3892
3893 if (NILP (obj))
3894 {
3895 obj = make_lispy_event (event);
3896
3897 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS)
3898 /* If this was a menu selection, then set the flag to inhibit
3899 writing to last_nonmenu_event. Don't do this if the event
3900 we're returning is (menu-bar), though; that indicates the
3901 beginning of the menu sequence, and we might as well leave
3902 that as the `event with parameters' for this selection. */
3903 if (used_mouse_menu
3904 && !EQ (event->frame_or_window, event->arg)
3905 && (event->kind == MENU_BAR_EVENT
3906 || event->kind == TOOL_BAR_EVENT))
3907 *used_mouse_menu = 1;
3908 #endif
3909
3910 /* Wipe out this event, to catch bugs. */
3911 clear_event (event);
3912 kbd_fetch_ptr = event + 1;
3913 }
3914 }
3915 }
3916 #ifdef HAVE_MOUSE
3917 /* Try generating a mouse motion event. */
3918 else if (!NILP (do_mouse_tracking) && some_mouse_moved ())
3919 {
3920 FRAME_PTR f = some_mouse_moved ();
3921 Lisp_Object bar_window;
3922 enum scroll_bar_part part;
3923 Lisp_Object x, y;
3924 unsigned long time;
3925
3926 *kbp = current_kboard;
3927 /* Note that this uses F to determine which display to look at.
3928 If there is no valid info, it does not store anything
3929 so x remains nil. */
3930 x = Qnil;
3931 (*mouse_position_hook) (&f, 0, &bar_window, &part, &x, &y, &time);
3932
3933 obj = Qnil;
3934
3935 /* Decide if we should generate a switch-frame event. Don't
3936 generate switch-frame events for motion outside of all Emacs
3937 frames. */
3938 if (!NILP (x) && f)
3939 {
3940 Lisp_Object frame;
3941
3942 frame = FRAME_FOCUS_FRAME (f);
3943 if (NILP (frame))
3944 XSETFRAME (frame, f);
3945
3946 if (! EQ (frame, internal_last_event_frame)
3947 && !EQ (frame, selected_frame))
3948 obj = make_lispy_switch_frame (frame);
3949 internal_last_event_frame = frame;
3950 }
3951
3952 /* If we didn't decide to make a switch-frame event, go ahead and
3953 return a mouse-motion event. */
3954 if (!NILP (x) && NILP (obj))
3955 obj = make_lispy_movement (f, bar_window, part, x, y, time);
3956 }
3957 #endif /* HAVE_MOUSE */
3958 else
3959 /* We were promised by the above while loop that there was
3960 something for us to read! */
3961 abort ();
3962
3963 input_pending = readable_events (0);
3964
3965 Vlast_event_frame = internal_last_event_frame;
3966
3967 return (obj);
3968 }
3969 \f
3970 /* Process any events that are not user-visible,
3971 then return, without reading any user-visible events. */
3972
3973 void
3974 swallow_events (do_display)
3975 int do_display;
3976 {
3977 int old_timers_run;
3978
3979 while (kbd_fetch_ptr != kbd_store_ptr)
3980 {
3981 struct input_event *event;
3982
3983 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
3984 ? kbd_fetch_ptr
3985 : kbd_buffer);
3986
3987 last_event_timestamp = event->timestamp;
3988
3989 /* These two kinds of events get special handling
3990 and don't actually appear to the command loop. */
3991 if (event->kind == SELECTION_REQUEST_EVENT)
3992 {
3993 #ifdef HAVE_X11
3994 struct input_event copy;
3995
3996 /* Remove it from the buffer before processing it,
3997 since otherwise swallow_events called recursively could see it
3998 and process it again. */
3999 copy = *event;
4000 kbd_fetch_ptr = event + 1;
4001 input_pending = readable_events (0);
4002 x_handle_selection_request (&copy);
4003 #else
4004 /* We're getting selection request events, but we don't have
4005 a window system. */
4006 abort ();
4007 #endif
4008 }
4009
4010 else if (event->kind == SELECTION_CLEAR_EVENT)
4011 {
4012 #ifdef HAVE_X11
4013 struct input_event copy;
4014
4015 /* Remove it from the buffer before processing it, */
4016 copy = *event;
4017
4018 kbd_fetch_ptr = event + 1;
4019 input_pending = readable_events (0);
4020 x_handle_selection_clear (&copy);
4021 #else
4022 /* We're getting selection request events, but we don't have
4023 a window system. */
4024 abort ();
4025 #endif
4026 }
4027 else
4028 break;
4029 }
4030
4031 old_timers_run = timers_run;
4032 get_input_pending (&input_pending, 1);
4033
4034 if (timers_run != old_timers_run && do_display)
4035 redisplay_preserve_echo_area (7);
4036 }
4037 \f
4038 /* Record the start of when Emacs is idle,
4039 for the sake of running idle-time timers. */
4040
4041 void
4042 timer_start_idle ()
4043 {
4044 Lisp_Object timers;
4045
4046 /* If we are already in the idle state, do nothing. */
4047 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4048 return;
4049
4050 EMACS_GET_TIME (timer_idleness_start_time);
4051
4052 timer_last_idleness_start_time = timer_idleness_start_time;
4053
4054 /* Mark all idle-time timers as once again candidates for running. */
4055 for (timers = Vtimer_idle_list; CONSP (timers); timers = XCDR (timers))
4056 {
4057 Lisp_Object timer;
4058
4059 timer = XCAR (timers);
4060
4061 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4062 continue;
4063 XVECTOR (timer)->contents[0] = Qnil;
4064 }
4065 }
4066
4067 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4068
4069 void
4070 timer_stop_idle ()
4071 {
4072 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
4073 }
4074
4075 /* This is only for debugging. */
4076 struct input_event last_timer_event;
4077
4078 /* Check whether a timer has fired. To prevent larger problems we simply
4079 disregard elements that are not proper timers. Do not make a circular
4080 timer list for the time being.
4081
4082 Returns the number of seconds to wait until the next timer fires. If a
4083 timer is triggering now, return zero seconds.
4084 If no timer is active, return -1 seconds.
4085
4086 If a timer is ripe, we run it, with quitting turned off.
4087
4088 DO_IT_NOW is now ignored. It used to mean that we should
4089 run the timer directly instead of queueing a timer-event.
4090 Now we always run timers directly. */
4091
4092 EMACS_TIME
4093 timer_check (do_it_now)
4094 int do_it_now;
4095 {
4096 EMACS_TIME nexttime;
4097 EMACS_TIME now, idleness_now;
4098 Lisp_Object timers, idle_timers, chosen_timer;
4099 struct gcpro gcpro1, gcpro2, gcpro3;
4100
4101 EMACS_SET_SECS (nexttime, -1);
4102 EMACS_SET_USECS (nexttime, -1);
4103
4104 /* Always consider the ordinary timers. */
4105 timers = Vtimer_list;
4106 /* Consider the idle timers only if Emacs is idle. */
4107 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4108 idle_timers = Vtimer_idle_list;
4109 else
4110 idle_timers = Qnil;
4111 chosen_timer = Qnil;
4112 GCPRO3 (timers, idle_timers, chosen_timer);
4113
4114 if (CONSP (timers) || CONSP (idle_timers))
4115 {
4116 EMACS_GET_TIME (now);
4117 if (! EMACS_TIME_NEG_P (timer_idleness_start_time))
4118 EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time);
4119 }
4120
4121 while (CONSP (timers) || CONSP (idle_timers))
4122 {
4123 Lisp_Object *vector;
4124 Lisp_Object timer = Qnil, idle_timer = Qnil;
4125 EMACS_TIME timer_time, idle_timer_time;
4126 EMACS_TIME difference, timer_difference, idle_timer_difference;
4127
4128 /* Skip past invalid timers and timers already handled. */
4129 if (!NILP (timers))
4130 {
4131 timer = XCAR (timers);
4132 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4133 {
4134 timers = XCDR (timers);
4135 continue;
4136 }
4137 vector = XVECTOR (timer)->contents;
4138
4139 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
4140 || !INTEGERP (vector[3])
4141 || ! NILP (vector[0]))
4142 {
4143 timers = XCDR (timers);
4144 continue;
4145 }
4146 }
4147 if (!NILP (idle_timers))
4148 {
4149 timer = XCAR (idle_timers);
4150 if (!VECTORP (timer) || XVECTOR (timer)->size != 8)
4151 {
4152 idle_timers = XCDR (idle_timers);
4153 continue;
4154 }
4155 vector = XVECTOR (timer)->contents;
4156
4157 if (!INTEGERP (vector[1]) || !INTEGERP (vector[2])
4158 || !INTEGERP (vector[3])
4159 || ! NILP (vector[0]))
4160 {
4161 idle_timers = XCDR (idle_timers);
4162 continue;
4163 }
4164 }
4165
4166 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4167 based on the next ordinary timer.
4168 TIMER_DIFFERENCE is the distance in time from NOW to when
4169 this timer becomes ripe (negative if it's already ripe). */
4170 if (!NILP (timers))
4171 {
4172 timer = XCAR (timers);
4173 vector = XVECTOR (timer)->contents;
4174 EMACS_SET_SECS (timer_time,
4175 (XINT (vector[1]) << 16) | (XINT (vector[2])));
4176 EMACS_SET_USECS (timer_time, XINT (vector[3]));
4177 EMACS_SUB_TIME (timer_difference, timer_time, now);
4178 }
4179
4180 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4181 based on the next idle timer. */
4182 if (!NILP (idle_timers))
4183 {
4184 idle_timer = XCAR (idle_timers);
4185 vector = XVECTOR (idle_timer)->contents;
4186 EMACS_SET_SECS (idle_timer_time,
4187 (XINT (vector[1]) << 16) | (XINT (vector[2])));
4188 EMACS_SET_USECS (idle_timer_time, XINT (vector[3]));
4189 EMACS_SUB_TIME (idle_timer_difference, idle_timer_time, idleness_now);
4190 }
4191
4192 /* Decide which timer is the next timer,
4193 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4194 Also step down the list where we found that timer. */
4195
4196 if (! NILP (timers) && ! NILP (idle_timers))
4197 {
4198 EMACS_TIME temp;
4199 EMACS_SUB_TIME (temp, timer_difference, idle_timer_difference);
4200 if (EMACS_TIME_NEG_P (temp))
4201 {
4202 chosen_timer = timer;
4203 timers = XCDR (timers);
4204 difference = timer_difference;
4205 }
4206 else
4207 {
4208 chosen_timer = idle_timer;
4209 idle_timers = XCDR (idle_timers);
4210 difference = idle_timer_difference;
4211 }
4212 }
4213 else if (! NILP (timers))
4214 {
4215 chosen_timer = timer;
4216 timers = XCDR (timers);
4217 difference = timer_difference;
4218 }
4219 else
4220 {
4221 chosen_timer = idle_timer;
4222 idle_timers = XCDR (idle_timers);
4223 difference = idle_timer_difference;
4224 }
4225 vector = XVECTOR (chosen_timer)->contents;
4226
4227 /* If timer is ripe, run it if it hasn't been run. */
4228 if (EMACS_TIME_NEG_P (difference)
4229 || (EMACS_SECS (difference) == 0
4230 && EMACS_USECS (difference) == 0))
4231 {
4232 if (NILP (vector[0]))
4233 {
4234 int was_locked = single_kboard;
4235 int count = SPECPDL_INDEX ();
4236 Lisp_Object old_deactivate_mark = Vdeactivate_mark;
4237
4238 /* Mark the timer as triggered to prevent problems if the lisp
4239 code fails to reschedule it right. */
4240 vector[0] = Qt;
4241
4242 specbind (Qinhibit_quit, Qt);
4243
4244 call1 (Qtimer_event_handler, chosen_timer);
4245 Vdeactivate_mark = old_deactivate_mark;
4246 timers_run++;
4247 unbind_to (count, Qnil);
4248
4249 /* Resume allowing input from any kboard, if that was true before. */
4250 if (!was_locked)
4251 any_kboard_state ();
4252
4253 /* Since we have handled the event,
4254 we don't need to tell the caller to wake up and do it. */
4255 }
4256 }
4257 else
4258 /* When we encounter a timer that is still waiting,
4259 return the amount of time to wait before it is ripe. */
4260 {
4261 UNGCPRO;
4262 return difference;
4263 }
4264 }
4265
4266 /* No timers are pending in the future. */
4267 /* Return 0 if we generated an event, and -1 if not. */
4268 UNGCPRO;
4269 return nexttime;
4270 }
4271 \f
4272 /* Caches for modify_event_symbol. */
4273 static Lisp_Object accent_key_syms;
4274 static Lisp_Object func_key_syms;
4275 static Lisp_Object mouse_syms;
4276 #if defined(WINDOWSNT) || defined(MAC_OSX)
4277 static Lisp_Object mouse_wheel_syms;
4278 #endif
4279 static Lisp_Object drag_n_drop_syms;
4280
4281 /* This is a list of keysym codes for special "accent" characters.
4282 It parallels lispy_accent_keys. */
4283
4284 static int lispy_accent_codes[] =
4285 {
4286 #ifdef XK_dead_circumflex
4287 XK_dead_circumflex,
4288 #else
4289 0,
4290 #endif
4291 #ifdef XK_dead_grave
4292 XK_dead_grave,
4293 #else
4294 0,
4295 #endif
4296 #ifdef XK_dead_tilde
4297 XK_dead_tilde,
4298 #else
4299 0,
4300 #endif
4301 #ifdef XK_dead_diaeresis
4302 XK_dead_diaeresis,
4303 #else
4304 0,
4305 #endif
4306 #ifdef XK_dead_macron
4307 XK_dead_macron,
4308 #else
4309 0,
4310 #endif
4311 #ifdef XK_dead_degree
4312 XK_dead_degree,
4313 #else
4314 0,
4315 #endif
4316 #ifdef XK_dead_acute
4317 XK_dead_acute,
4318 #else
4319 0,
4320 #endif
4321 #ifdef XK_dead_cedilla
4322 XK_dead_cedilla,
4323 #else
4324 0,
4325 #endif
4326 #ifdef XK_dead_breve
4327 XK_dead_breve,
4328 #else
4329 0,
4330 #endif
4331 #ifdef XK_dead_ogonek
4332 XK_dead_ogonek,
4333 #else
4334 0,
4335 #endif
4336 #ifdef XK_dead_caron
4337 XK_dead_caron,
4338 #else
4339 0,
4340 #endif
4341 #ifdef XK_dead_doubleacute
4342 XK_dead_doubleacute,
4343 #else
4344 0,
4345 #endif
4346 #ifdef XK_dead_abovedot
4347 XK_dead_abovedot,
4348 #else
4349 0,
4350 #endif
4351 #ifdef XK_dead_abovering
4352 XK_dead_abovering,
4353 #else
4354 0,
4355 #endif
4356 #ifdef XK_dead_iota
4357 XK_dead_iota,
4358 #else
4359 0,
4360 #endif
4361 #ifdef XK_dead_belowdot
4362 XK_dead_belowdot,
4363 #else
4364 0,
4365 #endif
4366 #ifdef XK_dead_voiced_sound
4367 XK_dead_voiced_sound,
4368 #else
4369 0,
4370 #endif
4371 #ifdef XK_dead_semivoiced_sound
4372 XK_dead_semivoiced_sound,
4373 #else
4374 0,
4375 #endif
4376 #ifdef XK_dead_hook
4377 XK_dead_hook,
4378 #else
4379 0,
4380 #endif
4381 #ifdef XK_dead_horn
4382 XK_dead_horn,
4383 #else
4384 0,
4385 #endif
4386 };
4387
4388 /* This is a list of Lisp names for special "accent" characters.
4389 It parallels lispy_accent_codes. */
4390
4391 static char *lispy_accent_keys[] =
4392 {
4393 "dead-circumflex",
4394 "dead-grave",
4395 "dead-tilde",
4396 "dead-diaeresis",
4397 "dead-macron",
4398 "dead-degree",
4399 "dead-acute",
4400 "dead-cedilla",
4401 "dead-breve",
4402 "dead-ogonek",
4403 "dead-caron",
4404 "dead-doubleacute",
4405 "dead-abovedot",
4406 "dead-abovering",
4407 "dead-iota",
4408 "dead-belowdot",
4409 "dead-voiced-sound",
4410 "dead-semivoiced-sound",
4411 "dead-hook",
4412 "dead-horn",
4413 };
4414
4415 #ifdef HAVE_NTGUI
4416 #define FUNCTION_KEY_OFFSET 0x0
4417
4418 char *lispy_function_keys[] =
4419 {
4420 0, /* 0 */
4421
4422 0, /* VK_LBUTTON 0x01 */
4423 0, /* VK_RBUTTON 0x02 */
4424 "cancel", /* VK_CANCEL 0x03 */
4425 0, /* VK_MBUTTON 0x04 */
4426
4427 0, 0, 0, /* 0x05 .. 0x07 */
4428
4429 "backspace", /* VK_BACK 0x08 */
4430 "tab", /* VK_TAB 0x09 */
4431
4432 0, 0, /* 0x0A .. 0x0B */
4433
4434 "clear", /* VK_CLEAR 0x0C */
4435 "return", /* VK_RETURN 0x0D */
4436
4437 0, 0, /* 0x0E .. 0x0F */
4438
4439 0, /* VK_SHIFT 0x10 */
4440 0, /* VK_CONTROL 0x11 */
4441 0, /* VK_MENU 0x12 */
4442 "pause", /* VK_PAUSE 0x13 */
4443 "capslock", /* VK_CAPITAL 0x14 */
4444
4445 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4446
4447 "escape", /* VK_ESCAPE 0x1B */
4448
4449 0, 0, 0, 0, /* 0x1C .. 0x1F */
4450
4451 0, /* VK_SPACE 0x20 */
4452 "prior", /* VK_PRIOR 0x21 */
4453 "next", /* VK_NEXT 0x22 */
4454 "end", /* VK_END 0x23 */
4455 "home", /* VK_HOME 0x24 */
4456 "left", /* VK_LEFT 0x25 */
4457 "up", /* VK_UP 0x26 */
4458 "right", /* VK_RIGHT 0x27 */
4459 "down", /* VK_DOWN 0x28 */
4460 "select", /* VK_SELECT 0x29 */
4461 "print", /* VK_PRINT 0x2A */
4462 "execute", /* VK_EXECUTE 0x2B */
4463 "snapshot", /* VK_SNAPSHOT 0x2C */
4464 "insert", /* VK_INSERT 0x2D */
4465 "delete", /* VK_DELETE 0x2E */
4466 "help", /* VK_HELP 0x2F */
4467
4468 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4469
4470 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4471
4472 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4473
4474 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4475
4476 0, 0, 0, 0, 0, 0, 0, 0, 0,
4477 0, 0, 0, 0, 0, 0, 0, 0, 0,
4478 0, 0, 0, 0, 0, 0, 0, 0,
4479
4480 "lwindow", /* VK_LWIN 0x5B */
4481 "rwindow", /* VK_RWIN 0x5C */
4482 "apps", /* VK_APPS 0x5D */
4483
4484 0, 0, /* 0x5E .. 0x5F */
4485
4486 "kp-0", /* VK_NUMPAD0 0x60 */
4487 "kp-1", /* VK_NUMPAD1 0x61 */
4488 "kp-2", /* VK_NUMPAD2 0x62 */
4489 "kp-3", /* VK_NUMPAD3 0x63 */
4490 "kp-4", /* VK_NUMPAD4 0x64 */
4491 "kp-5", /* VK_NUMPAD5 0x65 */
4492 "kp-6", /* VK_NUMPAD6 0x66 */
4493 "kp-7", /* VK_NUMPAD7 0x67 */
4494 "kp-8", /* VK_NUMPAD8 0x68 */
4495 "kp-9", /* VK_NUMPAD9 0x69 */
4496 "kp-multiply", /* VK_MULTIPLY 0x6A */
4497 "kp-add", /* VK_ADD 0x6B */
4498 "kp-separator", /* VK_SEPARATOR 0x6C */
4499 "kp-subtract", /* VK_SUBTRACT 0x6D */
4500 "kp-decimal", /* VK_DECIMAL 0x6E */
4501 "kp-divide", /* VK_DIVIDE 0x6F */
4502 "f1", /* VK_F1 0x70 */
4503 "f2", /* VK_F2 0x71 */
4504 "f3", /* VK_F3 0x72 */
4505 "f4", /* VK_F4 0x73 */
4506 "f5", /* VK_F5 0x74 */
4507 "f6", /* VK_F6 0x75 */
4508 "f7", /* VK_F7 0x76 */
4509 "f8", /* VK_F8 0x77 */
4510 "f9", /* VK_F9 0x78 */
4511 "f10", /* VK_F10 0x79 */
4512 "f11", /* VK_F11 0x7A */
4513 "f12", /* VK_F12 0x7B */
4514 "f13", /* VK_F13 0x7C */
4515 "f14", /* VK_F14 0x7D */
4516 "f15", /* VK_F15 0x7E */
4517 "f16", /* VK_F16 0x7F */
4518 "f17", /* VK_F17 0x80 */
4519 "f18", /* VK_F18 0x81 */
4520 "f19", /* VK_F19 0x82 */
4521 "f20", /* VK_F20 0x83 */
4522 "f21", /* VK_F21 0x84 */
4523 "f22", /* VK_F22 0x85 */
4524 "f23", /* VK_F23 0x86 */
4525 "f24", /* VK_F24 0x87 */
4526
4527 0, 0, 0, 0, /* 0x88 .. 0x8B */
4528 0, 0, 0, 0, /* 0x8C .. 0x8F */
4529
4530 "kp-numlock", /* VK_NUMLOCK 0x90 */
4531 "scroll", /* VK_SCROLL 0x91 */
4532
4533 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4534 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4535 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4536 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4537 "kp-end", /* VK_NUMPAD_END 0x96 */
4538 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4539 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4540 "kp-up", /* VK_NUMPAD_UP 0x99 */
4541 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4542 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4543 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4544 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4545
4546 0, 0, /* 0x9E .. 0x9F */
4547
4548 /*
4549 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4550 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4551 * No other API or message will distinguish left and right keys this way.
4552 */
4553 /* 0xA0 .. 0xEF */
4554
4555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4556 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4557 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4558 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4559 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4560
4561 /* 0xF0 .. 0xF5 */
4562
4563 0, 0, 0, 0, 0, 0,
4564
4565 "attn", /* VK_ATTN 0xF6 */
4566 "crsel", /* VK_CRSEL 0xF7 */
4567 "exsel", /* VK_EXSEL 0xF8 */
4568 "ereof", /* VK_EREOF 0xF9 */
4569 "play", /* VK_PLAY 0xFA */
4570 "zoom", /* VK_ZOOM 0xFB */
4571 "noname", /* VK_NONAME 0xFC */
4572 "pa1", /* VK_PA1 0xFD */
4573 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4574 0 /* 0xFF */
4575 };
4576
4577 #else /* not HAVE_NTGUI */
4578
4579 /* This should be dealt with in XTread_socket now, and that doesn't
4580 depend on the client system having the Kana syms defined. See also
4581 the XK_kana_A case below. */
4582 #if 0
4583 #ifdef XK_kana_A
4584 static char *lispy_kana_keys[] =
4585 {
4586 /* X Keysym value */
4587 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4588 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4589 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4590 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4591 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4592 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4593 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4594 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4595 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4596 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4597 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4598 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4599 "kana-i", "kana-u", "kana-e", "kana-o",
4600 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4601 "prolongedsound", "kana-A", "kana-I", "kana-U",
4602 "kana-E", "kana-O", "kana-KA", "kana-KI",
4603 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4604 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4605 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4606 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4607 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4608 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4609 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4610 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4611 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4612 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4613 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4614 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4615 };
4616 #endif /* XK_kana_A */
4617 #endif /* 0 */
4618
4619 #define FUNCTION_KEY_OFFSET 0xff00
4620
4621 /* You'll notice that this table is arranged to be conveniently
4622 indexed by X Windows keysym values. */
4623 static char *lispy_function_keys[] =
4624 {
4625 /* X Keysym value */
4626
4627 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4628 "backspace", "tab", "linefeed", "clear",
4629 0, "return", 0, 0,
4630 0, 0, 0, "pause", /* 0xff10...1f */
4631 0, 0, 0, 0, 0, 0, 0, "escape",
4632 0, 0, 0, 0,
4633 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4634 "romaji", "hiragana", "katakana", "hiragana-katakana",
4635 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4636 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4637 "eisu-toggle", /* 0xff30...3f */
4638 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4639 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4640
4641 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4642 "down", "prior", "next", "end",
4643 "begin", 0, 0, 0, 0, 0, 0, 0,
4644 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4645 "print",
4646 "execute",
4647 "insert",
4648 0, /* 0xff64 */
4649 "undo",
4650 "redo",
4651 "menu",
4652 "find",
4653 "cancel",
4654 "help",
4655 "break", /* 0xff6b */
4656
4657 0, 0, 0, 0,
4658 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4659 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4660 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4661 0, 0, 0, 0, 0, 0, 0, 0,
4662 "kp-tab", /* 0xff89 */
4663 0, 0, 0,
4664 "kp-enter", /* 0xff8d */
4665 0, 0, 0,
4666 "kp-f1", /* 0xff91 */
4667 "kp-f2",
4668 "kp-f3",
4669 "kp-f4",
4670 "kp-home", /* 0xff95 */
4671 "kp-left",
4672 "kp-up",
4673 "kp-right",
4674 "kp-down",
4675 "kp-prior", /* kp-page-up */
4676 "kp-next", /* kp-page-down */
4677 "kp-end",
4678 "kp-begin",
4679 "kp-insert",
4680 "kp-delete",
4681 0, /* 0xffa0 */
4682 0, 0, 0, 0, 0, 0, 0, 0, 0,
4683 "kp-multiply", /* 0xffaa */
4684 "kp-add",
4685 "kp-separator",
4686 "kp-subtract",
4687 "kp-decimal",
4688 "kp-divide", /* 0xffaf */
4689 "kp-0", /* 0xffb0 */
4690 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4691 0, /* 0xffba */
4692 0, 0,
4693 "kp-equal", /* 0xffbd */
4694 "f1", /* 0xffbe */ /* IsFunctionKey */
4695 "f2",
4696 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4697 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4698 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4699 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4700 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4701 0, 0, 0, 0, 0, 0, 0, 0,
4702 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4703 0, 0, 0, 0, 0, 0, 0, "delete"
4704 };
4705
4706 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4707 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4708
4709 static char *iso_lispy_function_keys[] =
4710 {
4711 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4712 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4713 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4714 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4715 "iso-lefttab", /* 0xfe20 */
4716 "iso-move-line-up", "iso-move-line-down",
4717 "iso-partial-line-up", "iso-partial-line-down",
4718 "iso-partial-space-left", "iso-partial-space-right",
4719 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4720 "iso-release-margin-left", "iso-release-margin-right",
4721 "iso-release-both-margins",
4722 "iso-fast-cursor-left", "iso-fast-cursor-right",
4723 "iso-fast-cursor-up", "iso-fast-cursor-down",
4724 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4725 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4726 };
4727
4728 #endif /* not HAVE_NTGUI */
4729
4730 Lisp_Object Vlispy_mouse_stem;
4731
4732 #if defined(WINDOWSNT) || defined(MAC_OSX)
4733 /* mouse-wheel events are generated by the wheel on devices such as
4734 the MS Intellimouse. The wheel sits in between the left and right
4735 mouse buttons, and is typically used to scroll or zoom the window
4736 underneath the pointer. mouse-wheel events specify the object on
4737 which they operate, and a delta corresponding to the amount and
4738 direction that the wheel is rotated. Clicking the mouse-wheel
4739 generates a mouse-2 event. */
4740 static char *lispy_mouse_wheel_names[] =
4741 {
4742 "mouse-wheel"
4743 };
4744
4745 #endif /* WINDOWSNT */
4746
4747 /* drag-n-drop events are generated when a set of selected files are
4748 dragged from another application and dropped onto an Emacs window. */
4749 static char *lispy_drag_n_drop_names[] =
4750 {
4751 "drag-n-drop"
4752 };
4753
4754 /* Scroll bar parts. */
4755 Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
4756 Lisp_Object Qup, Qdown, Qbottom, Qend_scroll;
4757 Lisp_Object Qtop, Qratio;
4758
4759 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
4760 Lisp_Object *scroll_bar_parts[] = {
4761 &Qabove_handle, &Qhandle, &Qbelow_handle,
4762 &Qup, &Qdown, &Qtop, &Qbottom, &Qend_scroll, &Qratio
4763 };
4764
4765 /* User signal events. */
4766 Lisp_Object Qusr1_signal, Qusr2_signal;
4767
4768 Lisp_Object *lispy_user_signals[] =
4769 {
4770 &Qusr1_signal, &Qusr2_signal
4771 };
4772
4773
4774 /* A vector, indexed by button number, giving the down-going location
4775 of currently depressed buttons, both scroll bar and non-scroll bar.
4776
4777 The elements have the form
4778 (BUTTON-NUMBER MODIFIER-MASK . REST)
4779 where REST is the cdr of a position as it would be reported in the event.
4780
4781 The make_lispy_event function stores positions here to tell the
4782 difference between click and drag events, and to store the starting
4783 location to be included in drag events. */
4784
4785 static Lisp_Object button_down_location;
4786
4787 /* Information about the most recent up-going button event: Which
4788 button, what location, and what time. */
4789
4790 static int last_mouse_button;
4791 static int last_mouse_x;
4792 static int last_mouse_y;
4793 static unsigned long button_down_time;
4794
4795 /* The maximum time between clicks to make a double-click, or Qnil to
4796 disable double-click detection, or Qt for no time limit. */
4797
4798 Lisp_Object Vdouble_click_time;
4799
4800 /* Maximum number of pixels the mouse may be moved between clicks
4801 to make a double-click. */
4802
4803 EMACS_INT double_click_fuzz;
4804
4805 /* The number of clicks in this multiple-click. */
4806
4807 int double_click_count;
4808
4809 /* Given a struct input_event, build the lisp event which represents
4810 it. If EVENT is 0, build a mouse movement event from the mouse
4811 movement buffer, which should have a movement event in it.
4812
4813 Note that events must be passed to this function in the order they
4814 are received; this function stores the location of button presses
4815 in order to build drag events when the button is released. */
4816
4817 static Lisp_Object
4818 make_lispy_event (event)
4819 struct input_event *event;
4820 {
4821 int i;
4822
4823 switch (SWITCH_ENUM_CAST (event->kind))
4824 {
4825 /* A simple keystroke. */
4826 case ASCII_KEYSTROKE_EVENT:
4827 {
4828 Lisp_Object lispy_c;
4829 int c = event->code & 0377;
4830 /* Turn ASCII characters into control characters
4831 when proper. */
4832 if (event->modifiers & ctrl_modifier)
4833 c = make_ctrl_char (c);
4834
4835 /* Add in the other modifier bits. We took care of ctrl_modifier
4836 just above, and the shift key was taken care of by the X code,
4837 and applied to control characters by make_ctrl_char. */
4838 c |= (event->modifiers
4839 & (meta_modifier | alt_modifier
4840 | hyper_modifier | super_modifier));
4841 /* Distinguish Shift-SPC from SPC. */
4842 if ((event->code & 0377) == 040
4843 && event->modifiers & shift_modifier)
4844 c |= shift_modifier;
4845 button_down_time = 0;
4846 XSETFASTINT (lispy_c, c);
4847 return lispy_c;
4848 }
4849
4850 case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
4851 {
4852 Lisp_Object lispy_c;
4853
4854 XSETFASTINT (lispy_c, event->code);
4855 return lispy_c;
4856 }
4857
4858 /* A function key. The symbol may need to have modifier prefixes
4859 tacked onto it. */
4860 case NON_ASCII_KEYSTROKE_EVENT:
4861 button_down_time = 0;
4862
4863 for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
4864 if (event->code == lispy_accent_codes[i])
4865 return modify_event_symbol (i,
4866 event->modifiers,
4867 Qfunction_key, Qnil,
4868 lispy_accent_keys, &accent_key_syms,
4869 (sizeof (lispy_accent_keys)
4870 / sizeof (lispy_accent_keys[0])));
4871
4872 #if 0
4873 #ifdef XK_kana_A
4874 if (event->code >= 0x400 && event->code < 0x500)
4875 return modify_event_symbol (event->code - 0x400,
4876 event->modifiers & ~shift_modifier,
4877 Qfunction_key, Qnil,
4878 lispy_kana_keys, &func_key_syms,
4879 (sizeof (lispy_kana_keys)
4880 / sizeof (lispy_kana_keys[0])));
4881 #endif /* XK_kana_A */
4882 #endif /* 0 */
4883
4884 #ifdef ISO_FUNCTION_KEY_OFFSET
4885 if (event->code < FUNCTION_KEY_OFFSET
4886 && event->code >= ISO_FUNCTION_KEY_OFFSET)
4887 return modify_event_symbol (event->code - ISO_FUNCTION_KEY_OFFSET,
4888 event->modifiers,
4889 Qfunction_key, Qnil,
4890 iso_lispy_function_keys, &func_key_syms,
4891 (sizeof (iso_lispy_function_keys)
4892 / sizeof (iso_lispy_function_keys[0])));
4893 #endif
4894
4895 /* Handle system-specific or unknown keysyms. */
4896 if (event->code & (1 << 28)
4897 || event->code - FUNCTION_KEY_OFFSET < 0
4898 || (event->code - FUNCTION_KEY_OFFSET
4899 >= sizeof lispy_function_keys / sizeof *lispy_function_keys)
4900 || !lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
4901 {
4902 /* We need to use an alist rather than a vector as the cache
4903 since we can't make a vector long enuf. */
4904 if (NILP (current_kboard->system_key_syms))
4905 current_kboard->system_key_syms = Fcons (Qnil, Qnil);
4906 return modify_event_symbol (event->code,
4907 event->modifiers,
4908 Qfunction_key,
4909 current_kboard->Vsystem_key_alist,
4910 0, &current_kboard->system_key_syms,
4911 (unsigned) -1);
4912 }
4913
4914 return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
4915 event->modifiers,
4916 Qfunction_key, Qnil,
4917 lispy_function_keys, &func_key_syms,
4918 (sizeof (lispy_function_keys)
4919 / sizeof (lispy_function_keys[0])));
4920
4921 #ifdef HAVE_MOUSE
4922 /* A mouse click. Figure out where it is, decide whether it's
4923 a press, click or drag, and build the appropriate structure. */
4924 case MOUSE_CLICK_EVENT:
4925 #ifndef USE_TOOLKIT_SCROLL_BARS
4926 case SCROLL_BAR_CLICK_EVENT:
4927 #endif
4928 {
4929 int button = event->code;
4930 int is_double;
4931 Lisp_Object position;
4932 Lisp_Object *start_pos_ptr;
4933 Lisp_Object start_pos;
4934 Lisp_Object window;
4935
4936 position = Qnil;
4937
4938 /* Build the position as appropriate for this mouse click. */
4939 if (event->kind == MOUSE_CLICK_EVENT)
4940 {
4941 int part;
4942 struct frame *f = XFRAME (event->frame_or_window);
4943 Lisp_Object posn;
4944 Lisp_Object string_info = Qnil;
4945 int row, column;
4946
4947 /* Ignore mouse events that were made on frame that
4948 have been deleted. */
4949 if (! FRAME_LIVE_P (f))
4950 return Qnil;
4951
4952 /* EVENT->x and EVENT->y are frame-relative pixel
4953 coordinates at this place. Under old redisplay, COLUMN
4954 and ROW are set to frame relative glyph coordinates
4955 which are then used to determine whether this click is
4956 in a menu (non-toolkit version). */
4957 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
4958 &column, &row, NULL, 1);
4959
4960 #ifndef USE_X_TOOLKIT
4961 /* In the non-toolkit version, clicks on the menu bar
4962 are ordinary button events in the event buffer.
4963 Distinguish them, and invoke the menu.
4964
4965 (In the toolkit version, the toolkit handles the menu bar
4966 and Emacs doesn't know about it until after the user
4967 makes a selection.) */
4968 if (row >= 0 && row < FRAME_MENU_BAR_LINES (f)
4969 && (event->modifiers & down_modifier))
4970 {
4971 Lisp_Object items, item;
4972 int hpos;
4973 int i;
4974
4975 #if 0
4976 /* Activate the menu bar on the down event. If the
4977 up event comes in before the menu code can deal with it,
4978 just ignore it. */
4979 if (! (event->modifiers & down_modifier))
4980 return Qnil;
4981 #endif
4982
4983 /* Find the menu bar item under `column'. */
4984 item = Qnil;
4985 items = FRAME_MENU_BAR_ITEMS (f);
4986 for (i = 0; i < XVECTOR (items)->size; i += 4)
4987 {
4988 Lisp_Object pos, string;
4989 string = AREF (items, i + 1);
4990 pos = AREF (items, i + 3);
4991 if (NILP (string))
4992 break;
4993 if (column >= XINT (pos)
4994 && column < XINT (pos) + SCHARS (string))
4995 {
4996 item = AREF (items, i);
4997 break;
4998 }
4999 }
5000
5001 /* ELisp manual 2.4b says (x y) are window relative but
5002 code says they are frame-relative. */
5003 position
5004 = Fcons (event->frame_or_window,
5005 Fcons (Qmenu_bar,
5006 Fcons (Fcons (event->x, event->y),
5007 Fcons (make_number (event->timestamp),
5008 Qnil))));
5009
5010 return Fcons (item, Fcons (position, Qnil));
5011 }
5012 #endif /* not USE_X_TOOLKIT */
5013
5014 /* Set `window' to the window under frame pixel coordinates
5015 event->x/event->y. */
5016 window = window_from_coordinates (f, XINT (event->x),
5017 XINT (event->y), &part, 0);
5018
5019 if (!WINDOWP (window))
5020 {
5021 window = event->frame_or_window;
5022 posn = Qnil;
5023 }
5024 else
5025 {
5026 /* It's a click in window window at frame coordinates
5027 event->x/ event->y. */
5028 struct window *w = XWINDOW (window);
5029
5030 /* Get window relative coordinates. Original code
5031 `rounded' this to glyph boundaries. */
5032 int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
5033 int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
5034
5035 /* Set event coordinates to window-relative coordinates
5036 for constructing the Lisp event below. */
5037 XSETINT (event->x, wx);
5038 XSETINT (event->y, wy);
5039
5040 if (part == 1 || part == 3)
5041 {
5042 /* Mode line or header line. Look for a string under
5043 the mouse that may have a `local-map' property. */
5044 Lisp_Object string;
5045 int charpos;
5046
5047 posn = part == 1 ? Qmode_line : Qheader_line;
5048 string = mode_line_string (w, wx, wy, part == 1, &charpos);
5049 if (STRINGP (string))
5050 string_info = Fcons (string, make_number (charpos));
5051 }
5052 else if (part == 2)
5053 posn = Qvertical_line;
5054 else if (part == 6 || part == 7)
5055 {
5056 int charpos;
5057 Lisp_Object object = marginal_area_string (w, wx, wy, part,
5058 &charpos);
5059 posn = (part == 6) ? Qleft_margin : Qright_margin;
5060 if (STRINGP (object))
5061 string_info = Fcons (object, make_number (charpos));
5062 }
5063 else
5064 {
5065 Lisp_Object object;
5066 struct display_pos p;
5067 buffer_posn_from_coords (w, &wx, &wy, &object, &p);
5068 posn = make_number (CHARPOS (p.pos));
5069 if (STRINGP (object))
5070 string_info
5071 = Fcons (object,
5072 make_number (CHARPOS (p.string_pos)));
5073 }
5074 }
5075
5076 position
5077 = Fcons (window,
5078 Fcons (posn,
5079 Fcons (Fcons (event->x, event->y),
5080 Fcons (make_number (event->timestamp),
5081 (NILP (string_info)
5082 ? Qnil
5083 : Fcons (string_info, Qnil))))));
5084 }
5085 #ifndef USE_TOOLKIT_SCROLL_BARS
5086 else
5087 {
5088 /* It's a scrollbar click. */
5089 Lisp_Object portion_whole;
5090 Lisp_Object part;
5091
5092 window = event->frame_or_window;
5093 portion_whole = Fcons (event->x, event->y);
5094 part = *scroll_bar_parts[(int) event->part];
5095
5096 position
5097 = Fcons (window,
5098 Fcons (Qvertical_scroll_bar,
5099 Fcons (portion_whole,
5100 Fcons (make_number (event->timestamp),
5101 Fcons (part, Qnil)))));
5102 }
5103 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5104
5105 if (button >= ASIZE (button_down_location))
5106 {
5107 button_down_location = larger_vector (button_down_location,
5108 button + 1, Qnil);
5109 mouse_syms = larger_vector (mouse_syms, button + 1, Qnil);
5110 }
5111
5112 start_pos_ptr = &AREF (button_down_location, button);
5113 start_pos = *start_pos_ptr;
5114 *start_pos_ptr = Qnil;
5115
5116 {
5117 /* On window-system frames, use the value of
5118 double-click-fuzz as is. On other frames, interpret it
5119 as a multiple of 1/8 characters. */
5120 struct frame *f;
5121 int fuzz;
5122
5123 if (WINDOWP (event->frame_or_window))
5124 f = XFRAME (XWINDOW (event->frame_or_window)->frame);
5125 else if (FRAMEP (event->frame_or_window))
5126 f = XFRAME (event->frame_or_window);
5127 else
5128 abort ();
5129
5130 if (FRAME_WINDOW_P (f))
5131 fuzz = double_click_fuzz;
5132 else
5133 fuzz = double_click_fuzz / 8;
5134
5135 is_double = (button == last_mouse_button
5136 && (abs (XINT (event->x) - last_mouse_x) <= fuzz)
5137 && (abs (XINT (event->y) - last_mouse_y) <= fuzz)
5138 && button_down_time != 0
5139 && (EQ (Vdouble_click_time, Qt)
5140 || (INTEGERP (Vdouble_click_time)
5141 && ((int)(event->timestamp - button_down_time)
5142 < XINT (Vdouble_click_time)))));
5143 }
5144
5145 last_mouse_button = button;
5146 last_mouse_x = XINT (event->x);
5147 last_mouse_y = XINT (event->y);
5148
5149 /* If this is a button press, squirrel away the location, so
5150 we can decide later whether it was a click or a drag. */
5151 if (event->modifiers & down_modifier)
5152 {
5153 if (is_double)
5154 {
5155 double_click_count++;
5156 event->modifiers |= ((double_click_count > 2)
5157 ? triple_modifier
5158 : double_modifier);
5159 }
5160 else
5161 double_click_count = 1;
5162 button_down_time = event->timestamp;
5163 *start_pos_ptr = Fcopy_alist (position);
5164 }
5165
5166 /* Now we're releasing a button - check the co-ordinates to
5167 see if this was a click or a drag. */
5168 else if (event->modifiers & up_modifier)
5169 {
5170 /* If we did not see a down before this up, ignore the up.
5171 Probably this happened because the down event chose a
5172 menu item. It would be an annoyance to treat the
5173 release of the button that chose the menu item as a
5174 separate event. */
5175
5176 if (!CONSP (start_pos))
5177 return Qnil;
5178
5179 event->modifiers &= ~up_modifier;
5180 #if 0 /* Formerly we treated an up with no down as a click event. */
5181 if (!CONSP (start_pos))
5182 event->modifiers |= click_modifier;
5183 else
5184 #endif
5185 {
5186 Lisp_Object down;
5187 EMACS_INT xdiff = double_click_fuzz, ydiff = double_click_fuzz;
5188
5189 /* The third element of every position
5190 should be the (x,y) pair. */
5191 down = Fcar (Fcdr (Fcdr (start_pos)));
5192 if (CONSP (down)
5193 && INTEGERP (XCAR (down)) && INTEGERP (XCDR (down)))
5194 {
5195 xdiff = XFASTINT (event->x) - XFASTINT (XCAR (down));
5196 ydiff = XFASTINT (event->y) - XFASTINT (XCDR (down));
5197 }
5198
5199 if (xdiff < double_click_fuzz && xdiff > - double_click_fuzz
5200 && ydiff < double_click_fuzz
5201 && ydiff > - double_click_fuzz)
5202 /* Mouse hasn't moved (much). */
5203 event->modifiers |= click_modifier;
5204 else
5205 {
5206 button_down_time = 0;
5207 event->modifiers |= drag_modifier;
5208 }
5209
5210 /* Don't check is_double; treat this as multiple
5211 if the down-event was multiple. */
5212 if (double_click_count > 1)
5213 event->modifiers |= ((double_click_count > 2)
5214 ? triple_modifier
5215 : double_modifier);
5216 }
5217 }
5218 else
5219 /* Every mouse event should either have the down_modifier or
5220 the up_modifier set. */
5221 abort ();
5222
5223 {
5224 /* Get the symbol we should use for the mouse click. */
5225 Lisp_Object head;
5226
5227 head = modify_event_symbol (button,
5228 event->modifiers,
5229 Qmouse_click, Vlispy_mouse_stem,
5230 NULL,
5231 &mouse_syms,
5232 XVECTOR (mouse_syms)->size);
5233 if (event->modifiers & drag_modifier)
5234 return Fcons (head,
5235 Fcons (start_pos,
5236 Fcons (position,
5237 Qnil)));
5238 else if (event->modifiers & (double_modifier | triple_modifier))
5239 return Fcons (head,
5240 Fcons (position,
5241 Fcons (make_number (double_click_count),
5242 Qnil)));
5243 else
5244 return Fcons (head,
5245 Fcons (position,
5246 Qnil));
5247 }
5248 }
5249
5250 #ifdef USE_TOOLKIT_SCROLL_BARS
5251
5252 /* We don't have down and up events if using toolkit scroll bars,
5253 so make this always a click event. Store in the `part' of
5254 the Lisp event a symbol which maps to the following actions:
5255
5256 `above_handle' page up
5257 `below_handle' page down
5258 `up' line up
5259 `down' line down
5260 `top' top of buffer
5261 `bottom' bottom of buffer
5262 `handle' thumb has been dragged.
5263 `end-scroll' end of interaction with scroll bar
5264
5265 The incoming input_event contains in its `part' member an
5266 index of type `enum scroll_bar_part' which we can use as an
5267 index in scroll_bar_parts to get the appropriate symbol. */
5268
5269 case SCROLL_BAR_CLICK_EVENT:
5270 {
5271 Lisp_Object position, head, window, portion_whole, part;
5272
5273 window = event->frame_or_window;
5274 portion_whole = Fcons (event->x, event->y);
5275 part = *scroll_bar_parts[(int) event->part];
5276
5277 position
5278 = Fcons (window,
5279 Fcons (Qvertical_scroll_bar,
5280 Fcons (portion_whole,
5281 Fcons (make_number (event->timestamp),
5282 Fcons (part, Qnil)))));
5283
5284 /* Always treat scroll bar events as clicks. */
5285 event->modifiers |= click_modifier;
5286 event->modifiers &= ~up_modifier;
5287
5288 /* Get the symbol we should use for the mouse click. */
5289 head = modify_event_symbol (event->code,
5290 event->modifiers,
5291 Qmouse_click,
5292 Vlispy_mouse_stem,
5293 NULL, &mouse_syms,
5294 XVECTOR (mouse_syms)->size);
5295 return Fcons (head, Fcons (position, Qnil));
5296 }
5297
5298 #endif /* USE_TOOLKIT_SCROLL_BARS */
5299
5300 #ifdef WINDOWSNT
5301 case W32_SCROLL_BAR_CLICK_EVENT:
5302 {
5303 int button = event->code;
5304 int is_double;
5305 Lisp_Object position;
5306 Lisp_Object *start_pos_ptr;
5307 Lisp_Object start_pos;
5308
5309 {
5310 Lisp_Object window;
5311 Lisp_Object portion_whole;
5312 Lisp_Object part;
5313
5314 window = event->frame_or_window;
5315 portion_whole = Fcons (event->x, event->y);
5316 part = *scroll_bar_parts[(int) event->part];
5317
5318 position
5319 = Fcons (window,
5320 Fcons (Qvertical_scroll_bar,
5321 Fcons (portion_whole,
5322 Fcons (make_number (event->timestamp),
5323 Fcons (part, Qnil)))));
5324 }
5325
5326 /* Always treat W32 scroll bar events as clicks. */
5327 event->modifiers |= click_modifier;
5328
5329 {
5330 /* Get the symbol we should use for the mouse click. */
5331 Lisp_Object head;
5332
5333 head = modify_event_symbol (button,
5334 event->modifiers,
5335 Qmouse_click,
5336 Vlispy_mouse_stem,
5337 NULL, &mouse_syms,
5338 XVECTOR (mouse_syms)->size);
5339 return Fcons (head,
5340 Fcons (position,
5341 Qnil));
5342 }
5343 }
5344 #endif /* WINDOWSNT */
5345 #if defined(WINDOWSNT) || defined(MAC_OSX)
5346 case MOUSE_WHEEL_EVENT:
5347 {
5348 int part;
5349 FRAME_PTR f = XFRAME (event->frame_or_window);
5350 Lisp_Object window;
5351 Lisp_Object posn;
5352 Lisp_Object head, position;
5353 int row, column;
5354
5355 /* Ignore mouse events that were made on frame that
5356 have been deleted. */
5357 if (! FRAME_LIVE_P (f))
5358 return Qnil;
5359 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
5360 &column, &row, NULL, 1);
5361 window = window_from_coordinates (f, XINT (event->x),
5362 XINT (event->y), &part, 0);
5363
5364 if (!WINDOWP (window))
5365 {
5366 window = event->frame_or_window;
5367 posn = Qnil;
5368 }
5369 else
5370 {
5371 int pixcolumn, pixrow;
5372 column -= XINT (XWINDOW (window)->left);
5373 row -= XINT (XWINDOW (window)->top);
5374 glyph_to_pixel_coords (XWINDOW(window), column, row,
5375 &pixcolumn, &pixrow);
5376 XSETINT (event->x, pixcolumn);
5377 XSETINT (event->y, pixrow);
5378
5379 if (part == 1)
5380 posn = Qmode_line;
5381 else if (part == 2)
5382 posn = Qvertical_line;
5383 else if (part == 3)
5384 posn = Qheader_line;
5385 else
5386 {
5387 Lisp_Object object;
5388 struct display_pos p;
5389 buffer_posn_from_coords (XWINDOW (window), &column, &row,
5390 &object, &p);
5391 posn = make_number (CHARPOS (p.pos));
5392 }
5393 }
5394
5395 {
5396 Lisp_Object head, position;
5397
5398 position
5399 = Fcons (window,
5400 Fcons (posn,
5401 Fcons (Fcons (event->x, event->y),
5402 Fcons (make_number (event->timestamp),
5403 Qnil))));
5404
5405 head = modify_event_symbol (0, event->modifiers,
5406 Qmouse_wheel, Qnil,
5407 lispy_mouse_wheel_names,
5408 &mouse_wheel_syms, 1);
5409 return Fcons (head,
5410 Fcons (position,
5411 /* Insert 1 here so event-click-count works. */
5412 Fcons (make_number (1),
5413 Fcons (make_number (event->code),
5414 Qnil))));
5415 }
5416 }
5417 #endif /* WINDOWSNT || MAC_OSX */
5418
5419 case DRAG_N_DROP_EVENT:
5420 {
5421 int part;
5422 FRAME_PTR f;
5423 Lisp_Object window;
5424 Lisp_Object posn;
5425 Lisp_Object files;
5426
5427 /* The frame_or_window field should be a cons of the frame in
5428 which the event occurred and a list of the filenames
5429 dropped. */
5430 if (! CONSP (event->frame_or_window))
5431 abort ();
5432
5433 f = XFRAME (XCAR (event->frame_or_window));
5434 files = XCDR (event->frame_or_window);
5435
5436 /* Ignore mouse events that were made on frames that
5437 have been deleted. */
5438 if (! FRAME_LIVE_P (f))
5439 return Qnil;
5440
5441 window = window_from_coordinates (f, XINT (event->x),
5442 XINT (event->y), &part, 0);
5443
5444 if (!WINDOWP (window))
5445 {
5446 window = XCAR (event->frame_or_window);
5447 posn = Qnil;
5448 }
5449 else
5450 {
5451 /* It's an event in window `window' at frame coordinates
5452 event->x/ event->y. */
5453 struct window *w = XWINDOW (window);
5454
5455 /* Get window relative coordinates. */
5456 int wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (event->x));
5457 int wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (event->y));
5458
5459 /* Set event coordinates to window-relative coordinates
5460 for constructing the Lisp event below. */
5461 XSETINT (event->x, wx);
5462 XSETINT (event->y, wy);
5463
5464 if (part == 1)
5465 posn = Qmode_line;
5466 else if (part == 2)
5467 posn = Qvertical_line;
5468 else if (part == 3)
5469 posn = Qheader_line;
5470 else
5471 {
5472 Lisp_Object object;
5473 struct display_pos p;
5474 buffer_posn_from_coords (w, &wx, &wy, &object, &p);
5475 posn = make_number (CHARPOS (p.pos));
5476 }
5477 }
5478
5479 {
5480 Lisp_Object head, position;
5481
5482 position
5483 = Fcons (window,
5484 Fcons (posn,
5485 Fcons (Fcons (event->x, event->y),
5486 Fcons (make_number (event->timestamp),
5487 Qnil))));
5488
5489 head = modify_event_symbol (0, event->modifiers,
5490 Qdrag_n_drop, Qnil,
5491 lispy_drag_n_drop_names,
5492 &drag_n_drop_syms, 1);
5493 return Fcons (head,
5494 Fcons (position,
5495 Fcons (files,
5496 Qnil)));
5497 }
5498 }
5499 #endif /* HAVE_MOUSE */
5500
5501 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
5502 case MENU_BAR_EVENT:
5503 if (EQ (event->arg, event->frame_or_window))
5504 /* This is the prefix key. We translate this to
5505 `(menu_bar)' because the code in keyboard.c for menu
5506 events, which we use, relies on this. */
5507 return Fcons (Qmenu_bar, Qnil);
5508 return event->arg;
5509 #endif
5510
5511 case TOOL_BAR_EVENT:
5512 if (EQ (event->arg, event->frame_or_window))
5513 /* This is the prefix key. We translate this to
5514 `(tool_bar)' because the code in keyboard.c for tool bar
5515 events, which we use, relies on this. */
5516 return Fcons (Qtool_bar, Qnil);
5517 else if (SYMBOLP (event->arg))
5518 return apply_modifiers (event->modifiers, event->arg);
5519 return event->arg;
5520
5521 case USER_SIGNAL_EVENT:
5522 /* A user signal. */
5523 return *lispy_user_signals[event->code];
5524
5525 case SAVE_SESSION_EVENT:
5526 return Qsave_session;
5527
5528 /* The 'kind' field of the event is something we don't recognize. */
5529 default:
5530 abort ();
5531 }
5532 }
5533
5534 #ifdef HAVE_MOUSE
5535
5536 static Lisp_Object
5537 make_lispy_movement (frame, bar_window, part, x, y, time)
5538 FRAME_PTR frame;
5539 Lisp_Object bar_window;
5540 enum scroll_bar_part part;
5541 Lisp_Object x, y;
5542 unsigned long time;
5543 {
5544 /* Is it a scroll bar movement? */
5545 if (frame && ! NILP (bar_window))
5546 {
5547 Lisp_Object part_sym;
5548
5549 part_sym = *scroll_bar_parts[(int) part];
5550 return Fcons (Qscroll_bar_movement,
5551 (Fcons (Fcons (bar_window,
5552 Fcons (Qvertical_scroll_bar,
5553 Fcons (Fcons (x, y),
5554 Fcons (make_number (time),
5555 Fcons (part_sym,
5556 Qnil))))),
5557 Qnil)));
5558 }
5559
5560 /* Or is it an ordinary mouse movement? */
5561 else
5562 {
5563 int area;
5564 Lisp_Object window;
5565 Lisp_Object posn;
5566
5567 if (frame)
5568 /* It's in a frame; which window on that frame? */
5569 window = window_from_coordinates (frame, XINT (x), XINT (y), &area, 0);
5570 else
5571 window = Qnil;
5572
5573 if (WINDOWP (window))
5574 {
5575 struct window *w = XWINDOW (window);
5576 int wx, wy;
5577
5578 /* Get window relative coordinates. */
5579 wx = FRAME_TO_WINDOW_PIXEL_X (w, XINT (x));
5580 wy = FRAME_TO_WINDOW_PIXEL_Y (w, XINT (y));
5581 XSETINT (x, wx);
5582 XSETINT (y, wy);
5583
5584 if (area == 1)
5585 posn = Qmode_line;
5586 else if (area == 2)
5587 posn = Qvertical_line;
5588 else if (area == 3)
5589 posn = Qheader_line;
5590 else
5591 {
5592 Lisp_Object object;
5593 struct display_pos p;
5594 buffer_posn_from_coords (w, &wx, &wy, &object, &p);
5595 posn = make_number (CHARPOS (p.pos));
5596 }
5597 }
5598 else if (frame != 0)
5599 {
5600 XSETFRAME (window, frame);
5601 posn = Qnil;
5602 }
5603 else
5604 {
5605 window = Qnil;
5606 posn = Qnil;
5607 XSETFASTINT (x, 0);
5608 XSETFASTINT (y, 0);
5609 }
5610
5611 return Fcons (Qmouse_movement,
5612 Fcons (Fcons (window,
5613 Fcons (posn,
5614 Fcons (Fcons (x, y),
5615 Fcons (make_number (time),
5616 Qnil)))),
5617 Qnil));
5618 }
5619 }
5620
5621 #endif /* HAVE_MOUSE */
5622
5623 /* Construct a switch frame event. */
5624 static Lisp_Object
5625 make_lispy_switch_frame (frame)
5626 Lisp_Object frame;
5627 {
5628 return Fcons (Qswitch_frame, Fcons (frame, Qnil));
5629 }
5630 \f
5631 /* Manipulating modifiers. */
5632
5633 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5634
5635 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5636 SYMBOL's name of the end of the modifiers; the string from this
5637 position is the unmodified symbol name.
5638
5639 This doesn't use any caches. */
5640
5641 static int
5642 parse_modifiers_uncached (symbol, modifier_end)
5643 Lisp_Object symbol;
5644 int *modifier_end;
5645 {
5646 Lisp_Object name;
5647 int i;
5648 int modifiers;
5649
5650 CHECK_SYMBOL (symbol);
5651
5652 modifiers = 0;
5653 name = SYMBOL_NAME (symbol);
5654
5655 for (i = 0; i+2 <= SBYTES (name); )
5656 {
5657 int this_mod_end = 0;
5658 int this_mod = 0;
5659
5660 /* See if the name continues with a modifier word.
5661 Check that the word appears, but don't check what follows it.
5662 Set this_mod and this_mod_end to record what we find. */
5663
5664 switch (SREF (name, i))
5665 {
5666 #define SINGLE_LETTER_MOD(BIT) \
5667 (this_mod_end = i + 1, this_mod = BIT)
5668
5669 case 'A':
5670 SINGLE_LETTER_MOD (alt_modifier);
5671 break;
5672
5673 case 'C':
5674 SINGLE_LETTER_MOD (ctrl_modifier);
5675 break;
5676
5677 case 'H':
5678 SINGLE_LETTER_MOD (hyper_modifier);
5679 break;
5680
5681 case 'M':
5682 SINGLE_LETTER_MOD (meta_modifier);
5683 break;
5684
5685 case 'S':
5686 SINGLE_LETTER_MOD (shift_modifier);
5687 break;
5688
5689 case 's':
5690 SINGLE_LETTER_MOD (super_modifier);
5691 break;
5692
5693 #undef SINGLE_LETTER_MOD
5694 }
5695
5696 /* If we found no modifier, stop looking for them. */
5697 if (this_mod_end == 0)
5698 break;
5699
5700 /* Check there is a dash after the modifier, so that it
5701 really is a modifier. */
5702 if (this_mod_end >= SBYTES (name)
5703 || SREF (name, this_mod_end) != '-')
5704 break;
5705
5706 /* This modifier is real; look for another. */
5707 modifiers |= this_mod;
5708 i = this_mod_end + 1;
5709 }
5710
5711 /* Should we include the `click' modifier? */
5712 if (! (modifiers & (down_modifier | drag_modifier
5713 | double_modifier | triple_modifier))
5714 && i + 7 == SBYTES (name)
5715 && strncmp (SDATA (name) + i, "mouse-", 6) == 0
5716 && ('0' <= SREF (name, i + 6) && SREF (name, i + 6) <= '9'))
5717 modifiers |= click_modifier;
5718
5719 if (modifier_end)
5720 *modifier_end = i;
5721
5722 return modifiers;
5723 }
5724
5725 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5726 prepended to the string BASE[0..BASE_LEN-1].
5727 This doesn't use any caches. */
5728 static Lisp_Object
5729 apply_modifiers_uncached (modifiers, base, base_len, base_len_byte)
5730 int modifiers;
5731 char *base;
5732 int base_len, base_len_byte;
5733 {
5734 /* Since BASE could contain nulls, we can't use intern here; we have
5735 to use Fintern, which expects a genuine Lisp_String, and keeps a
5736 reference to it. */
5737 char *new_mods
5738 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
5739 int mod_len;
5740
5741 {
5742 char *p = new_mods;
5743
5744 /* Only the event queue may use the `up' modifier; it should always
5745 be turned into a click or drag event before presented to lisp code. */
5746 if (modifiers & up_modifier)
5747 abort ();
5748
5749 if (modifiers & alt_modifier) { *p++ = 'A'; *p++ = '-'; }
5750 if (modifiers & ctrl_modifier) { *p++ = 'C'; *p++ = '-'; }
5751 if (modifiers & hyper_modifier) { *p++ = 'H'; *p++ = '-'; }
5752 if (modifiers & meta_modifier) { *p++ = 'M'; *p++ = '-'; }
5753 if (modifiers & shift_modifier) { *p++ = 'S'; *p++ = '-'; }
5754 if (modifiers & super_modifier) { *p++ = 's'; *p++ = '-'; }
5755 if (modifiers & double_modifier) { strcpy (p, "double-"); p += 7; }
5756 if (modifiers & triple_modifier) { strcpy (p, "triple-"); p += 7; }
5757 if (modifiers & down_modifier) { strcpy (p, "down-"); p += 5; }
5758 if (modifiers & drag_modifier) { strcpy (p, "drag-"); p += 5; }
5759 /* The click modifier is denoted by the absence of other modifiers. */
5760
5761 *p = '\0';
5762
5763 mod_len = p - new_mods;
5764 }
5765
5766 {
5767 Lisp_Object new_name;
5768
5769 new_name = make_uninit_multibyte_string (mod_len + base_len,
5770 mod_len + base_len_byte);
5771 bcopy (new_mods, SDATA (new_name), mod_len);
5772 bcopy (base, SDATA (new_name) + mod_len, base_len_byte);
5773
5774 return Fintern (new_name, Qnil);
5775 }
5776 }
5777
5778
5779 static char *modifier_names[] =
5780 {
5781 "up", "down", "drag", "click", "double", "triple", 0, 0,
5782 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5783 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
5784 };
5785 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
5786
5787 static Lisp_Object modifier_symbols;
5788
5789 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
5790 static Lisp_Object
5791 lispy_modifier_list (modifiers)
5792 int modifiers;
5793 {
5794 Lisp_Object modifier_list;
5795 int i;
5796
5797 modifier_list = Qnil;
5798 for (i = 0; (1<<i) <= modifiers && i < NUM_MOD_NAMES; i++)
5799 if (modifiers & (1<<i))
5800 modifier_list = Fcons (XVECTOR (modifier_symbols)->contents[i],
5801 modifier_list);
5802
5803 return modifier_list;
5804 }
5805
5806
5807 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
5808 where UNMODIFIED is the unmodified form of SYMBOL,
5809 MASK is the set of modifiers present in SYMBOL's name.
5810 This is similar to parse_modifiers_uncached, but uses the cache in
5811 SYMBOL's Qevent_symbol_element_mask property, and maintains the
5812 Qevent_symbol_elements property. */
5813
5814 Lisp_Object
5815 parse_modifiers (symbol)
5816 Lisp_Object symbol;
5817 {
5818 Lisp_Object elements;
5819
5820 elements = Fget (symbol, Qevent_symbol_element_mask);
5821 if (CONSP (elements))
5822 return elements;
5823 else
5824 {
5825 int end;
5826 int modifiers = parse_modifiers_uncached (symbol, &end);
5827 Lisp_Object unmodified;
5828 Lisp_Object mask;
5829
5830 unmodified = Fintern (make_string (SDATA (SYMBOL_NAME (symbol)) + end,
5831 SBYTES (SYMBOL_NAME (symbol)) - end),
5832 Qnil);
5833
5834 if (modifiers & ~VALMASK)
5835 abort ();
5836 XSETFASTINT (mask, modifiers);
5837 elements = Fcons (unmodified, Fcons (mask, Qnil));
5838
5839 /* Cache the parsing results on SYMBOL. */
5840 Fput (symbol, Qevent_symbol_element_mask,
5841 elements);
5842 Fput (symbol, Qevent_symbol_elements,
5843 Fcons (unmodified, lispy_modifier_list (modifiers)));
5844
5845 /* Since we know that SYMBOL is modifiers applied to unmodified,
5846 it would be nice to put that in unmodified's cache.
5847 But we can't, since we're not sure that parse_modifiers is
5848 canonical. */
5849
5850 return elements;
5851 }
5852 }
5853
5854 /* Apply the modifiers MODIFIERS to the symbol BASE.
5855 BASE must be unmodified.
5856
5857 This is like apply_modifiers_uncached, but uses BASE's
5858 Qmodifier_cache property, if present. It also builds
5859 Qevent_symbol_elements properties, since it has that info anyway.
5860
5861 apply_modifiers copies the value of BASE's Qevent_kind property to
5862 the modified symbol. */
5863 static Lisp_Object
5864 apply_modifiers (modifiers, base)
5865 int modifiers;
5866 Lisp_Object base;
5867 {
5868 Lisp_Object cache, index, entry, new_symbol;
5869
5870 /* Mask out upper bits. We don't know where this value's been. */
5871 modifiers &= VALMASK;
5872
5873 /* The click modifier never figures into cache indices. */
5874 cache = Fget (base, Qmodifier_cache);
5875 XSETFASTINT (index, (modifiers & ~click_modifier));
5876 entry = assq_no_quit (index, cache);
5877
5878 if (CONSP (entry))
5879 new_symbol = XCDR (entry);
5880 else
5881 {
5882 /* We have to create the symbol ourselves. */
5883 new_symbol = apply_modifiers_uncached (modifiers,
5884 SDATA (SYMBOL_NAME (base)),
5885 SCHARS (SYMBOL_NAME (base)),
5886 SBYTES (SYMBOL_NAME (base)));
5887
5888 /* Add the new symbol to the base's cache. */
5889 entry = Fcons (index, new_symbol);
5890 Fput (base, Qmodifier_cache, Fcons (entry, cache));
5891
5892 /* We have the parsing info now for free, so add it to the caches. */
5893 XSETFASTINT (index, modifiers);
5894 Fput (new_symbol, Qevent_symbol_element_mask,
5895 Fcons (base, Fcons (index, Qnil)));
5896 Fput (new_symbol, Qevent_symbol_elements,
5897 Fcons (base, lispy_modifier_list (modifiers)));
5898 }
5899
5900 /* Make sure this symbol is of the same kind as BASE.
5901
5902 You'd think we could just set this once and for all when we
5903 intern the symbol above, but reorder_modifiers may call us when
5904 BASE's property isn't set right; we can't assume that just
5905 because it has a Qmodifier_cache property it must have its
5906 Qevent_kind set right as well. */
5907 if (NILP (Fget (new_symbol, Qevent_kind)))
5908 {
5909 Lisp_Object kind;
5910
5911 kind = Fget (base, Qevent_kind);
5912 if (! NILP (kind))
5913 Fput (new_symbol, Qevent_kind, kind);
5914 }
5915
5916 return new_symbol;
5917 }
5918
5919
5920 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
5921 return a symbol with the modifiers placed in the canonical order.
5922 Canonical order is alphabetical, except for down and drag, which
5923 always come last. The 'click' modifier is never written out.
5924
5925 Fdefine_key calls this to make sure that (for example) C-M-foo
5926 and M-C-foo end up being equivalent in the keymap. */
5927
5928 Lisp_Object
5929 reorder_modifiers (symbol)
5930 Lisp_Object symbol;
5931 {
5932 /* It's hopefully okay to write the code this way, since everything
5933 will soon be in caches, and no consing will be done at all. */
5934 Lisp_Object parsed;
5935
5936 parsed = parse_modifiers (symbol);
5937 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed))),
5938 XCAR (parsed));
5939 }
5940
5941
5942 /* For handling events, we often want to produce a symbol whose name
5943 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
5944 to some base, like the name of a function key or mouse button.
5945 modify_event_symbol produces symbols of this sort.
5946
5947 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
5948 is the name of the i'th symbol. TABLE_SIZE is the number of elements
5949 in the table.
5950
5951 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
5952 into symbol names, or a string specifying a name stem used to
5953 construct a symbol name or the form `STEM-N', where N is the decimal
5954 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
5955 non-nil; otherwise NAME_TABLE is used.
5956
5957 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
5958 persist between calls to modify_event_symbol that it can use to
5959 store a cache of the symbols it's generated for this NAME_TABLE
5960 before. The object stored there may be a vector or an alist.
5961
5962 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
5963
5964 MODIFIERS is a set of modifier bits (as given in struct input_events)
5965 whose prefixes should be applied to the symbol name.
5966
5967 SYMBOL_KIND is the value to be placed in the event_kind property of
5968 the returned symbol.
5969
5970 The symbols we create are supposed to have an
5971 `event-symbol-elements' property, which lists the modifiers present
5972 in the symbol's name. */
5973
5974 static Lisp_Object
5975 modify_event_symbol (symbol_num, modifiers, symbol_kind, name_alist_or_stem,
5976 name_table, symbol_table, table_size)
5977 int symbol_num;
5978 unsigned modifiers;
5979 Lisp_Object symbol_kind;
5980 Lisp_Object name_alist_or_stem;
5981 char **name_table;
5982 Lisp_Object *symbol_table;
5983 unsigned int table_size;
5984 {
5985 Lisp_Object value;
5986 Lisp_Object symbol_int;
5987
5988 /* Get rid of the "vendor-specific" bit here. */
5989 XSETINT (symbol_int, symbol_num & 0xffffff);
5990
5991 /* Is this a request for a valid symbol? */
5992 if (symbol_num < 0 || symbol_num >= table_size)
5993 return Qnil;
5994
5995 if (CONSP (*symbol_table))
5996 value = Fcdr (assq_no_quit (symbol_int, *symbol_table));
5997
5998 /* If *symbol_table doesn't seem to be initialized properly, fix that.
5999 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6000 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6001 we've never used that symbol before. */
6002 else
6003 {
6004 if (! VECTORP (*symbol_table)
6005 || XVECTOR (*symbol_table)->size != table_size)
6006 {
6007 Lisp_Object size;
6008
6009 XSETFASTINT (size, table_size);
6010 *symbol_table = Fmake_vector (size, Qnil);
6011 }
6012
6013 value = XVECTOR (*symbol_table)->contents[symbol_num];
6014 }
6015
6016 /* Have we already used this symbol before? */
6017 if (NILP (value))
6018 {
6019 /* No; let's create it. */
6020 if (CONSP (name_alist_or_stem))
6021 value = Fcdr_safe (Fassq (symbol_int, name_alist_or_stem));
6022 else if (STRINGP (name_alist_or_stem))
6023 {
6024 int len = SBYTES (name_alist_or_stem);
6025 char *buf = (char *) alloca (len + 50);
6026 if (sizeof (int) == sizeof (EMACS_INT))
6027 sprintf (buf, "%s-%d", SDATA (name_alist_or_stem),
6028 XINT (symbol_int) + 1);
6029 else if (sizeof (long) == sizeof (EMACS_INT))
6030 sprintf (buf, "%s-%ld", SDATA (name_alist_or_stem),
6031 XINT (symbol_int) + 1);
6032 value = intern (buf);
6033 }
6034 else if (name_table != 0 && name_table[symbol_num])
6035 value = intern (name_table[symbol_num]);
6036
6037 #ifdef HAVE_WINDOW_SYSTEM
6038 if (NILP (value))
6039 {
6040 char *name = x_get_keysym_name (symbol_num);
6041 if (name)
6042 value = intern (name);
6043 }
6044 #endif
6045
6046 if (NILP (value))
6047 {
6048 char buf[20];
6049 sprintf (buf, "key-%d", symbol_num);
6050 value = intern (buf);
6051 }
6052
6053 if (CONSP (*symbol_table))
6054 *symbol_table = Fcons (Fcons (symbol_int, value), *symbol_table);
6055 else
6056 XVECTOR (*symbol_table)->contents[symbol_num] = value;
6057
6058 /* Fill in the cache entries for this symbol; this also
6059 builds the Qevent_symbol_elements property, which the user
6060 cares about. */
6061 apply_modifiers (modifiers & click_modifier, value);
6062 Fput (value, Qevent_kind, symbol_kind);
6063 }
6064
6065 /* Apply modifiers to that symbol. */
6066 return apply_modifiers (modifiers, value);
6067 }
6068 \f
6069 /* Convert a list that represents an event type,
6070 such as (ctrl meta backspace), into the usual representation of that
6071 event type as a number or a symbol. */
6072
6073 DEFUN ("event-convert-list", Fevent_convert_list, Sevent_convert_list, 1, 1, 0,
6074 doc: /* Convert the event description list EVENT-DESC to an event type.
6075 EVENT-DESC should contain one base event type (a character or symbol)
6076 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6077 drag, down, double or triple). The base must be last.
6078 The return value is an event type (a character or symbol) which
6079 has the same base event type and all the specified modifiers. */)
6080 (event_desc)
6081 Lisp_Object event_desc;
6082 {
6083 Lisp_Object base;
6084 int modifiers = 0;
6085 Lisp_Object rest;
6086
6087 base = Qnil;
6088 rest = event_desc;
6089 while (CONSP (rest))
6090 {
6091 Lisp_Object elt;
6092 int this = 0;
6093
6094 elt = XCAR (rest);
6095 rest = XCDR (rest);
6096
6097 /* Given a symbol, see if it is a modifier name. */
6098 if (SYMBOLP (elt) && CONSP (rest))
6099 this = parse_solitary_modifier (elt);
6100
6101 if (this != 0)
6102 modifiers |= this;
6103 else if (!NILP (base))
6104 error ("Two bases given in one event");
6105 else
6106 base = elt;
6107
6108 }
6109
6110 /* Let the symbol A refer to the character A. */
6111 if (SYMBOLP (base) && SCHARS (SYMBOL_NAME (base)) == 1)
6112 XSETINT (base, SREF (SYMBOL_NAME (base), 0));
6113
6114 if (INTEGERP (base))
6115 {
6116 /* Turn (shift a) into A. */
6117 if ((modifiers & shift_modifier) != 0
6118 && (XINT (base) >= 'a' && XINT (base) <= 'z'))
6119 {
6120 XSETINT (base, XINT (base) - ('a' - 'A'));
6121 modifiers &= ~shift_modifier;
6122 }
6123
6124 /* Turn (control a) into C-a. */
6125 if (modifiers & ctrl_modifier)
6126 return make_number ((modifiers & ~ctrl_modifier)
6127 | make_ctrl_char (XINT (base)));
6128 else
6129 return make_number (modifiers | XINT (base));
6130 }
6131 else if (SYMBOLP (base))
6132 return apply_modifiers (modifiers, base);
6133 else
6134 {
6135 error ("Invalid base event");
6136 return Qnil;
6137 }
6138 }
6139
6140 /* Try to recognize SYMBOL as a modifier name.
6141 Return the modifier flag bit, or 0 if not recognized. */
6142
6143 static int
6144 parse_solitary_modifier (symbol)
6145 Lisp_Object symbol;
6146 {
6147 Lisp_Object name = SYMBOL_NAME (symbol);
6148
6149 switch (SREF (name, 0))
6150 {
6151 #define SINGLE_LETTER_MOD(BIT) \
6152 if (SBYTES (name) == 1) \
6153 return BIT;
6154
6155 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6156 if (LEN == SBYTES (name) \
6157 && ! strncmp (SDATA (name), NAME, LEN)) \
6158 return BIT;
6159
6160 case 'A':
6161 SINGLE_LETTER_MOD (alt_modifier);
6162 break;
6163
6164 case 'a':
6165 MULTI_LETTER_MOD (alt_modifier, "alt", 3);
6166 break;
6167
6168 case 'C':
6169 SINGLE_LETTER_MOD (ctrl_modifier);
6170 break;
6171
6172 case 'c':
6173 MULTI_LETTER_MOD (ctrl_modifier, "ctrl", 4);
6174 MULTI_LETTER_MOD (ctrl_modifier, "control", 7);
6175 break;
6176
6177 case 'H':
6178 SINGLE_LETTER_MOD (hyper_modifier);
6179 break;
6180
6181 case 'h':
6182 MULTI_LETTER_MOD (hyper_modifier, "hyper", 5);
6183 break;
6184
6185 case 'M':
6186 SINGLE_LETTER_MOD (meta_modifier);
6187 break;
6188
6189 case 'm':
6190 MULTI_LETTER_MOD (meta_modifier, "meta", 4);
6191 break;
6192
6193 case 'S':
6194 SINGLE_LETTER_MOD (shift_modifier);
6195 break;
6196
6197 case 's':
6198 MULTI_LETTER_MOD (shift_modifier, "shift", 5);
6199 MULTI_LETTER_MOD (super_modifier, "super", 5);
6200 SINGLE_LETTER_MOD (super_modifier);
6201 break;
6202
6203 case 'd':
6204 MULTI_LETTER_MOD (drag_modifier, "drag", 4);
6205 MULTI_LETTER_MOD (down_modifier, "down", 4);
6206 MULTI_LETTER_MOD (double_modifier, "double", 6);
6207 break;
6208
6209 case 't':
6210 MULTI_LETTER_MOD (triple_modifier, "triple", 6);
6211 break;
6212
6213 #undef SINGLE_LETTER_MOD
6214 #undef MULTI_LETTER_MOD
6215 }
6216
6217 return 0;
6218 }
6219
6220 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6221 Such a list is not valid as an event,
6222 but it can be a Lucid-style event type list. */
6223
6224 int
6225 lucid_event_type_list_p (object)
6226 Lisp_Object object;
6227 {
6228 Lisp_Object tail;
6229
6230 if (! CONSP (object))
6231 return 0;
6232
6233 if (EQ (XCAR (object), Qhelp_echo)
6234 || EQ (XCAR (object), Qvertical_line)
6235 || EQ (XCAR (object), Qmode_line)
6236 || EQ (XCAR (object), Qheader_line))
6237 return 0;
6238
6239 for (tail = object; CONSP (tail); tail = XCDR (tail))
6240 {
6241 Lisp_Object elt;
6242 elt = XCAR (tail);
6243 if (! (INTEGERP (elt) || SYMBOLP (elt)))
6244 return 0;
6245 }
6246
6247 return NILP (tail);
6248 }
6249 \f
6250 /* Store into *addr a value nonzero if terminal input chars are available.
6251 Serves the purpose of ioctl (0, FIONREAD, addr)
6252 but works even if FIONREAD does not exist.
6253 (In fact, this may actually read some input.)
6254
6255 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
6256 If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
6257
6258 static void
6259 get_filtered_input_pending (addr, do_timers_now, filter_events)
6260 int *addr;
6261 int do_timers_now;
6262 int filter_events;
6263 {
6264 /* First of all, have we already counted some input? */
6265 *addr = (!NILP (Vquit_flag)
6266 || readable_filtered_events (do_timers_now, filter_events));
6267
6268 /* If input is being read as it arrives, and we have none, there is none. */
6269 if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
6270 return;
6271
6272 /* Try to read some input and see how much we get. */
6273 gobble_input (0);
6274 *addr = (!NILP (Vquit_flag)
6275 || readable_filtered_events (do_timers_now, filter_events));
6276 }
6277
6278 /* Store into *addr a value nonzero if terminal input chars are available.
6279 Serves the purpose of ioctl (0, FIONREAD, addr)
6280 but works even if FIONREAD does not exist.
6281 (In fact, this may actually read some input.)
6282
6283 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
6284
6285 static void
6286 get_input_pending (addr, do_timers_now)
6287 int *addr;
6288 int do_timers_now;
6289 {
6290 get_filtered_input_pending (addr, do_timers_now, 0);
6291 }
6292
6293 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6294
6295 void
6296 gobble_input (expected)
6297 int expected;
6298 {
6299 #ifndef VMS
6300 #ifdef SIGIO
6301 if (interrupt_input)
6302 {
6303 SIGMASKTYPE mask;
6304 mask = sigblock (sigmask (SIGIO));
6305 read_avail_input (expected);
6306 sigsetmask (mask);
6307 }
6308 else
6309 #ifdef POLL_FOR_INPUT
6310 if (read_socket_hook && !interrupt_input && poll_suppress_count == 0)
6311 {
6312 SIGMASKTYPE mask;
6313 mask = sigblock (sigmask (SIGALRM));
6314 read_avail_input (expected);
6315 sigsetmask (mask);
6316 }
6317 else
6318 #endif
6319 #endif
6320 read_avail_input (expected);
6321 #endif
6322 }
6323
6324 /* Put a BUFFER_SWITCH_EVENT in the buffer
6325 so that read_key_sequence will notice the new current buffer. */
6326
6327 void
6328 record_asynch_buffer_change ()
6329 {
6330 struct input_event event;
6331 Lisp_Object tem;
6332
6333 event.kind = BUFFER_SWITCH_EVENT;
6334 event.frame_or_window = Qnil;
6335 event.arg = Qnil;
6336
6337 #ifdef subprocesses
6338 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6339 The purpose of the event is to make read_key_sequence look up the
6340 keymaps again. If we aren't in read_key_sequence, we don't need one,
6341 and the event could cause trouble by messing up (input-pending-p). */
6342 tem = Fwaiting_for_user_input_p ();
6343 if (NILP (tem))
6344 return;
6345 #else
6346 /* We never need these events if we have no asynchronous subprocesses. */
6347 return;
6348 #endif
6349
6350 /* Make sure no interrupt happens while storing the event. */
6351 #ifdef SIGIO
6352 if (interrupt_input)
6353 {
6354 SIGMASKTYPE mask;
6355 mask = sigblock (sigmask (SIGIO));
6356 kbd_buffer_store_event (&event);
6357 sigsetmask (mask);
6358 }
6359 else
6360 #endif
6361 {
6362 stop_polling ();
6363 kbd_buffer_store_event (&event);
6364 start_polling ();
6365 }
6366 }
6367 \f
6368 #ifndef VMS
6369
6370 /* Read any terminal input already buffered up by the system
6371 into the kbd_buffer, but do not wait.
6372
6373 EXPECTED should be nonzero if the caller knows there is some input.
6374
6375 Except on VMS, all input is read by this function.
6376 If interrupt_input is nonzero, this function MUST be called
6377 only when SIGIO is blocked.
6378
6379 Returns the number of keyboard chars read, or -1 meaning
6380 this is a bad time to try to read input. */
6381
6382 static int
6383 read_avail_input (expected)
6384 int expected;
6385 {
6386 struct input_event buf[KBD_BUFFER_SIZE];
6387 register int i;
6388 int nread;
6389
6390 if (read_socket_hook)
6391 /* No need for FIONREAD or fcntl; just say don't wait. */
6392 nread = (*read_socket_hook) (input_fd, buf, KBD_BUFFER_SIZE, expected);
6393 else
6394 {
6395 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6396 the kbd_buffer can really hold. That may prevent loss
6397 of characters on some systems when input is stuffed at us. */
6398 unsigned char cbuf[KBD_BUFFER_SIZE - 1];
6399 int n_to_read;
6400
6401 /* Determine how many characters we should *try* to read. */
6402 #ifdef WINDOWSNT
6403 return 0;
6404 #else /* not WINDOWSNT */
6405 #ifdef MSDOS
6406 n_to_read = dos_keysns ();
6407 if (n_to_read == 0)
6408 return 0;
6409 #else /* not MSDOS */
6410 #ifdef FIONREAD
6411 /* Find out how much input is available. */
6412 if (ioctl (input_fd, FIONREAD, &n_to_read) < 0)
6413 /* Formerly simply reported no input, but that sometimes led to
6414 a failure of Emacs to terminate.
6415 SIGHUP seems appropriate if we can't reach the terminal. */
6416 /* ??? Is it really right to send the signal just to this process
6417 rather than to the whole process group?
6418 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6419 kill (getpid (), SIGHUP);
6420 if (n_to_read == 0)
6421 return 0;
6422 if (n_to_read > sizeof cbuf)
6423 n_to_read = sizeof cbuf;
6424 #else /* no FIONREAD */
6425 #if defined (USG) || defined (DGUX)
6426 /* Read some input if available, but don't wait. */
6427 n_to_read = sizeof cbuf;
6428 fcntl (input_fd, F_SETFL, O_NDELAY);
6429 #else
6430 you lose;
6431 #endif
6432 #endif
6433 #endif /* not MSDOS */
6434 #endif /* not WINDOWSNT */
6435
6436 /* Now read; for one reason or another, this will not block.
6437 NREAD is set to the number of chars read. */
6438 do
6439 {
6440 #ifdef MSDOS
6441 cbuf[0] = dos_keyread ();
6442 nread = 1;
6443 #else
6444 nread = emacs_read (input_fd, cbuf, n_to_read);
6445 #endif
6446 /* POSIX infers that processes which are not in the session leader's
6447 process group won't get SIGHUP's at logout time. BSDI adheres to
6448 this part standard and returns -1 from read (0) with errno==EIO
6449 when the control tty is taken away.
6450 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6451 if (nread == -1 && errno == EIO)
6452 kill (0, SIGHUP);
6453 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6454 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6455 This looks incorrect, but it isn't, because _BSD causes
6456 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6457 and that causes a value other than 0 when there is no input. */
6458 if (nread == 0)
6459 kill (0, SIGHUP);
6460 #endif
6461 }
6462 while (
6463 /* We used to retry the read if it was interrupted.
6464 But this does the wrong thing when O_NDELAY causes
6465 an EAGAIN error. Does anybody know of a situation
6466 where a retry is actually needed? */
6467 #if 0
6468 nread < 0 && (errno == EAGAIN
6469 #ifdef EFAULT
6470 || errno == EFAULT
6471 #endif
6472 #ifdef EBADSLT
6473 || errno == EBADSLT
6474 #endif
6475 )
6476 #else
6477 0
6478 #endif
6479 );
6480
6481 #ifndef FIONREAD
6482 #if defined (USG) || defined (DGUX)
6483 fcntl (input_fd, F_SETFL, 0);
6484 #endif /* USG or DGUX */
6485 #endif /* no FIONREAD */
6486 for (i = 0; i < nread; i++)
6487 {
6488 buf[i].kind = ASCII_KEYSTROKE_EVENT;
6489 buf[i].modifiers = 0;
6490 if (meta_key == 1 && (cbuf[i] & 0x80))
6491 buf[i].modifiers = meta_modifier;
6492 if (meta_key != 2)
6493 cbuf[i] &= ~0x80;
6494
6495 buf[i].code = cbuf[i];
6496 buf[i].frame_or_window = selected_frame;
6497 buf[i].arg = Qnil;
6498 }
6499 }
6500
6501 /* Scan the chars for C-g and store them in kbd_buffer. */
6502 for (i = 0; i < nread; i++)
6503 {
6504 kbd_buffer_store_event (&buf[i]);
6505 /* Don't look at input that follows a C-g too closely.
6506 This reduces lossage due to autorepeat on C-g. */
6507 if (buf[i].kind == ASCII_KEYSTROKE_EVENT
6508 && buf[i].code == quit_char)
6509 break;
6510 }
6511
6512 return nread;
6513 }
6514 #endif /* not VMS */
6515 \f
6516 #ifdef SIGIO /* for entire page */
6517 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6518
6519 SIGTYPE
6520 input_available_signal (signo)
6521 int signo;
6522 {
6523 /* Must preserve main program's value of errno. */
6524 int old_errno = errno;
6525 #ifdef BSD4_1
6526 extern int select_alarmed;
6527 #endif
6528
6529 #if defined (USG) && !defined (POSIX_SIGNALS)
6530 /* USG systems forget handlers when they are used;
6531 must reestablish each time */
6532 signal (signo, input_available_signal);
6533 #endif /* USG */
6534
6535 #ifdef BSD4_1
6536 sigisheld (SIGIO);
6537 #endif
6538
6539 if (input_available_clear_time)
6540 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
6541
6542 while (1)
6543 {
6544 int nread;
6545 nread = read_avail_input (1);
6546 /* -1 means it's not ok to read the input now.
6547 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6548 0 means there was no keyboard input available. */
6549 if (nread <= 0)
6550 break;
6551
6552 #ifdef BSD4_1
6553 select_alarmed = 1; /* Force the select emulator back to life */
6554 #endif
6555 }
6556
6557 #ifdef BSD4_1
6558 sigfree ();
6559 #endif
6560 errno = old_errno;
6561 }
6562 #endif /* SIGIO */
6563
6564 /* Send ourselves a SIGIO.
6565
6566 This function exists so that the UNBLOCK_INPUT macro in
6567 blockinput.h can have some way to take care of input we put off
6568 dealing with, without assuming that every file which uses
6569 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6570 void
6571 reinvoke_input_signal ()
6572 {
6573 #ifdef SIGIO
6574 kill (getpid (), SIGIO);
6575 #endif
6576 }
6577
6578
6579 \f
6580 static void menu_bar_item P_ ((Lisp_Object, Lisp_Object));
6581 static void menu_bar_one_keymap P_ ((Lisp_Object));
6582
6583 /* These variables hold the vector under construction within
6584 menu_bar_items and its subroutines, and the current index
6585 for storing into that vector. */
6586 static Lisp_Object menu_bar_items_vector;
6587 static int menu_bar_items_index;
6588
6589 /* Return a vector of menu items for a menu bar, appropriate
6590 to the current buffer. Each item has three elements in the vector:
6591 KEY STRING MAPLIST.
6592
6593 OLD is an old vector we can optionally reuse, or nil. */
6594
6595 Lisp_Object
6596 menu_bar_items (old)
6597 Lisp_Object old;
6598 {
6599 /* The number of keymaps we're scanning right now, and the number of
6600 keymaps we have allocated space for. */
6601 int nmaps;
6602
6603 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6604 in the current keymaps, or nil where it is not a prefix. */
6605 Lisp_Object *maps;
6606
6607 Lisp_Object def, tail;
6608
6609 Lisp_Object result;
6610
6611 int mapno;
6612 Lisp_Object oquit;
6613
6614 int i;
6615
6616 struct gcpro gcpro1;
6617
6618 /* In order to build the menus, we need to call the keymap
6619 accessors. They all call QUIT. But this function is called
6620 during redisplay, during which a quit is fatal. So inhibit
6621 quitting while building the menus.
6622 We do this instead of specbind because (1) errors will clear it anyway
6623 and (2) this avoids risk of specpdl overflow. */
6624 oquit = Vinhibit_quit;
6625 Vinhibit_quit = Qt;
6626
6627 if (!NILP (old))
6628 menu_bar_items_vector = old;
6629 else
6630 menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
6631 menu_bar_items_index = 0;
6632
6633 GCPRO1 (menu_bar_items_vector);
6634
6635 /* Build our list of keymaps.
6636 If we recognize a function key and replace its escape sequence in
6637 keybuf with its symbol, or if the sequence starts with a mouse
6638 click and we need to switch buffers, we jump back here to rebuild
6639 the initial keymaps from the current buffer. */
6640 {
6641 Lisp_Object *tmaps;
6642
6643 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6644 if (!NILP (Voverriding_local_map_menu_flag))
6645 {
6646 /* Yes, use them (if non-nil) as well as the global map. */
6647 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
6648 nmaps = 0;
6649 if (!NILP (current_kboard->Voverriding_terminal_local_map))
6650 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
6651 if (!NILP (Voverriding_local_map))
6652 maps[nmaps++] = Voverriding_local_map;
6653 }
6654 else
6655 {
6656 /* No, so use major and minor mode keymaps and keymap property.
6657 Note that menu-bar bindings in the local-map and keymap
6658 properties may not work reliable, as they are only
6659 recognized when the menu-bar (or mode-line) is updated,
6660 which does not normally happen after every command. */
6661 Lisp_Object tem;
6662 int nminor;
6663 nminor = current_minor_maps (NULL, &tmaps);
6664 maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
6665 nmaps = 0;
6666 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
6667 maps[nmaps++] = tem;
6668 bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
6669 nmaps += nminor;
6670 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
6671 }
6672 maps[nmaps++] = current_global_map;
6673 }
6674
6675 /* Look up in each map the dummy prefix key `menu-bar'. */
6676
6677 result = Qnil;
6678
6679 for (mapno = nmaps - 1; mapno >= 0; mapno--)
6680 if (!NILP (maps[mapno]))
6681 {
6682 def = get_keymap (access_keymap (maps[mapno], Qmenu_bar, 1, 0, 1),
6683 0, 1);
6684 if (CONSP (def))
6685 menu_bar_one_keymap (def);
6686 }
6687
6688 /* Move to the end those items that should be at the end. */
6689
6690 for (tail = Vmenu_bar_final_items; CONSP (tail); tail = XCDR (tail))
6691 {
6692 int i;
6693 int end = menu_bar_items_index;
6694
6695 for (i = 0; i < end; i += 4)
6696 if (EQ (XCAR (tail), XVECTOR (menu_bar_items_vector)->contents[i]))
6697 {
6698 Lisp_Object tem0, tem1, tem2, tem3;
6699 /* Move the item at index I to the end,
6700 shifting all the others forward. */
6701 tem0 = XVECTOR (menu_bar_items_vector)->contents[i + 0];
6702 tem1 = XVECTOR (menu_bar_items_vector)->contents[i + 1];
6703 tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
6704 tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
6705 if (end > i + 4)
6706 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
6707 &XVECTOR (menu_bar_items_vector)->contents[i],
6708 (end - i - 4) * sizeof (Lisp_Object));
6709 XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
6710 XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
6711 XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
6712 XVECTOR (menu_bar_items_vector)->contents[end - 1] = tem3;
6713 break;
6714 }
6715 }
6716
6717 /* Add nil, nil, nil, nil at the end. */
6718 i = menu_bar_items_index;
6719 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
6720 {
6721 Lisp_Object tem;
6722 tem = Fmake_vector (make_number (2 * i), Qnil);
6723 bcopy (XVECTOR (menu_bar_items_vector)->contents,
6724 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
6725 menu_bar_items_vector = tem;
6726 }
6727 /* Add this item. */
6728 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6729 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6730 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6731 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
6732 menu_bar_items_index = i;
6733
6734 Vinhibit_quit = oquit;
6735 UNGCPRO;
6736 return menu_bar_items_vector;
6737 }
6738 \f
6739 /* Scan one map KEYMAP, accumulating any menu items it defines
6740 in menu_bar_items_vector. */
6741
6742 static Lisp_Object menu_bar_one_keymap_changed_items;
6743
6744 static void
6745 menu_bar_one_keymap (keymap)
6746 Lisp_Object keymap;
6747 {
6748 Lisp_Object tail, item;
6749
6750 menu_bar_one_keymap_changed_items = Qnil;
6751
6752 /* Loop over all keymap entries that have menu strings. */
6753 for (tail = keymap; CONSP (tail); tail = XCDR (tail))
6754 {
6755 item = XCAR (tail);
6756 if (CONSP (item))
6757 menu_bar_item (XCAR (item), XCDR (item));
6758 else if (VECTORP (item))
6759 {
6760 /* Loop over the char values represented in the vector. */
6761 int len = XVECTOR (item)->size;
6762 int c;
6763 for (c = 0; c < len; c++)
6764 {
6765 Lisp_Object character;
6766 XSETFASTINT (character, c);
6767 menu_bar_item (character, XVECTOR (item)->contents[c]);
6768 }
6769 }
6770 }
6771 }
6772
6773 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
6774 If there's already an item for KEY, add this DEF to it. */
6775
6776 Lisp_Object item_properties;
6777
6778 static void
6779 menu_bar_item (key, item)
6780 Lisp_Object key, item;
6781 {
6782 struct gcpro gcpro1;
6783 int i;
6784 Lisp_Object tem;
6785
6786 if (EQ (item, Qundefined))
6787 {
6788 /* If a map has an explicit `undefined' as definition,
6789 discard any previously made menu bar item. */
6790
6791 for (i = 0; i < menu_bar_items_index; i += 4)
6792 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
6793 {
6794 if (menu_bar_items_index > i + 4)
6795 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
6796 &XVECTOR (menu_bar_items_vector)->contents[i],
6797 (menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
6798 menu_bar_items_index -= 4;
6799 }
6800 }
6801
6802 /* If this keymap has already contributed to this KEY,
6803 don't contribute to it a second time. */
6804 tem = Fmemq (key, menu_bar_one_keymap_changed_items);
6805 if (!NILP (tem) || NILP (item))
6806 return;
6807
6808 menu_bar_one_keymap_changed_items
6809 = Fcons (key, menu_bar_one_keymap_changed_items);
6810
6811 /* We add to menu_bar_one_keymap_changed_items before doing the
6812 parse_menu_item, so that if it turns out it wasn't a menu item,
6813 it still correctly hides any further menu item. */
6814 GCPRO1 (key);
6815 i = parse_menu_item (item, 0, 1);
6816 UNGCPRO;
6817 if (!i)
6818 return;
6819
6820 item = XVECTOR (item_properties)->contents[ITEM_PROPERTY_DEF];
6821
6822 /* Find any existing item for this KEY. */
6823 for (i = 0; i < menu_bar_items_index; i += 4)
6824 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
6825 break;
6826
6827 /* If we did not find this KEY, add it at the end. */
6828 if (i == menu_bar_items_index)
6829 {
6830 /* If vector is too small, get a bigger one. */
6831 if (i + 4 > XVECTOR (menu_bar_items_vector)->size)
6832 {
6833 Lisp_Object tem;
6834 tem = Fmake_vector (make_number (2 * i), Qnil);
6835 bcopy (XVECTOR (menu_bar_items_vector)->contents,
6836 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
6837 menu_bar_items_vector = tem;
6838 }
6839
6840 /* Add this item. */
6841 XVECTOR (menu_bar_items_vector)->contents[i++] = key;
6842 XVECTOR (menu_bar_items_vector)->contents[i++]
6843 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
6844 XVECTOR (menu_bar_items_vector)->contents[i++] = Fcons (item, Qnil);
6845 XVECTOR (menu_bar_items_vector)->contents[i++] = make_number (0);
6846 menu_bar_items_index = i;
6847 }
6848 /* We did find an item for this KEY. Add ITEM to its list of maps. */
6849 else
6850 {
6851 Lisp_Object old;
6852 old = XVECTOR (menu_bar_items_vector)->contents[i + 2];
6853 XVECTOR (menu_bar_items_vector)->contents[i + 2] = Fcons (item, old);
6854 }
6855 }
6856 \f
6857 /* This is used as the handler when calling menu_item_eval_property. */
6858 static Lisp_Object
6859 menu_item_eval_property_1 (arg)
6860 Lisp_Object arg;
6861 {
6862 /* If we got a quit from within the menu computation,
6863 quit all the way out of it. This takes care of C-] in the debugger. */
6864 if (CONSP (arg) && EQ (XCAR (arg), Qquit))
6865 Fsignal (Qquit, Qnil);
6866
6867 return Qnil;
6868 }
6869
6870 /* Evaluate an expression and return the result (or nil if something
6871 went wrong). Used to evaluate dynamic parts of menu items. */
6872 Lisp_Object
6873 menu_item_eval_property (sexpr)
6874 Lisp_Object sexpr;
6875 {
6876 int count = SPECPDL_INDEX ();
6877 Lisp_Object val;
6878 specbind (Qinhibit_redisplay, Qt);
6879 val = internal_condition_case_1 (Feval, sexpr, Qerror,
6880 menu_item_eval_property_1);
6881 return unbind_to (count, val);
6882 }
6883
6884 /* This function parses a menu item and leaves the result in the
6885 vector item_properties.
6886 ITEM is a key binding, a possible menu item.
6887 If NOTREAL is nonzero, only check for equivalent key bindings, don't
6888 evaluate dynamic expressions in the menu item.
6889 INMENUBAR is > 0 when this is considered for an entry in a menu bar
6890 top level.
6891 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
6892 parse_menu_item returns true if the item is a menu item and false
6893 otherwise. */
6894
6895 int
6896 parse_menu_item (item, notreal, inmenubar)
6897 Lisp_Object item;
6898 int notreal, inmenubar;
6899 {
6900 Lisp_Object def, tem, item_string, start;
6901 Lisp_Object cachelist;
6902 Lisp_Object filter;
6903 Lisp_Object keyhint;
6904 int i;
6905 int newcache = 0;
6906
6907 cachelist = Qnil;
6908 filter = Qnil;
6909 keyhint = Qnil;
6910
6911 if (!CONSP (item))
6912 return 0;
6913
6914 /* Create item_properties vector if necessary. */
6915 if (NILP (item_properties))
6916 item_properties
6917 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE + 1), Qnil);
6918
6919 /* Initialize optional entries. */
6920 for (i = ITEM_PROPERTY_DEF; i < ITEM_PROPERTY_ENABLE; i++)
6921 AREF (item_properties, i) = Qnil;
6922 AREF (item_properties, ITEM_PROPERTY_ENABLE) = Qt;
6923
6924 /* Save the item here to protect it from GC. */
6925 AREF (item_properties, ITEM_PROPERTY_ITEM) = item;
6926
6927 item_string = XCAR (item);
6928
6929 start = item;
6930 item = XCDR (item);
6931 if (STRINGP (item_string))
6932 {
6933 /* Old format menu item. */
6934 AREF (item_properties, ITEM_PROPERTY_NAME) = item_string;
6935
6936 /* Maybe help string. */
6937 if (CONSP (item) && STRINGP (XCAR (item)))
6938 {
6939 AREF (item_properties, ITEM_PROPERTY_HELP) = XCAR (item);
6940 start = item;
6941 item = XCDR (item);
6942 }
6943
6944 /* Maybe key binding cache. */
6945 if (CONSP (item) && CONSP (XCAR (item))
6946 && (NILP (XCAR (XCAR (item)))
6947 || VECTORP (XCAR (XCAR (item)))))
6948 {
6949 cachelist = XCAR (item);
6950 item = XCDR (item);
6951 }
6952
6953 /* This is the real definition--the function to run. */
6954 AREF (item_properties, ITEM_PROPERTY_DEF) = item;
6955
6956 /* Get enable property, if any. */
6957 if (SYMBOLP (item))
6958 {
6959 tem = Fget (item, Qmenu_enable);
6960 if (!NILP (tem))
6961 AREF (item_properties, ITEM_PROPERTY_ENABLE) = tem;
6962 }
6963 }
6964 else if (EQ (item_string, Qmenu_item) && CONSP (item))
6965 {
6966 /* New format menu item. */
6967 AREF (item_properties, ITEM_PROPERTY_NAME) = XCAR (item);
6968 start = XCDR (item);
6969 if (CONSP (start))
6970 {
6971 /* We have a real binding. */
6972 AREF (item_properties, ITEM_PROPERTY_DEF) = XCAR (start);
6973
6974 item = XCDR (start);
6975 /* Is there a cache list with key equivalences. */
6976 if (CONSP (item) && CONSP (XCAR (item)))
6977 {
6978 cachelist = XCAR (item);
6979 item = XCDR (item);
6980 }
6981
6982 /* Parse properties. */
6983 while (CONSP (item) && CONSP (XCDR (item)))
6984 {
6985 tem = XCAR (item);
6986 item = XCDR (item);
6987
6988 if (EQ (tem, QCenable))
6989 AREF (item_properties, ITEM_PROPERTY_ENABLE) = XCAR (item);
6990 else if (EQ (tem, QCvisible) && !notreal)
6991 {
6992 /* If got a visible property and that evaluates to nil
6993 then ignore this item. */
6994 tem = menu_item_eval_property (XCAR (item));
6995 if (NILP (tem))
6996 return 0;
6997 }
6998 else if (EQ (tem, QChelp))
6999 AREF (item_properties, ITEM_PROPERTY_HELP) = XCAR (item);
7000 else if (EQ (tem, QCfilter))
7001 filter = item;
7002 else if (EQ (tem, QCkey_sequence))
7003 {
7004 tem = XCAR (item);
7005 if (NILP (cachelist)
7006 && (SYMBOLP (tem) || STRINGP (tem) || VECTORP (tem)))
7007 /* Be GC protected. Set keyhint to item instead of tem. */
7008 keyhint = item;
7009 }
7010 else if (EQ (tem, QCkeys))
7011 {
7012 tem = XCAR (item);
7013 if (CONSP (tem) || (STRINGP (tem) && NILP (cachelist)))
7014 AREF (item_properties, ITEM_PROPERTY_KEYEQ) = tem;
7015 }
7016 else if (EQ (tem, QCbutton) && CONSP (XCAR (item)))
7017 {
7018 Lisp_Object type;
7019 tem = XCAR (item);
7020 type = XCAR (tem);
7021 if (EQ (type, QCtoggle) || EQ (type, QCradio))
7022 {
7023 AREF (item_properties, ITEM_PROPERTY_SELECTED)
7024 = XCDR (tem);
7025 AREF (item_properties, ITEM_PROPERTY_TYPE)
7026 = type;
7027 }
7028 }
7029 item = XCDR (item);
7030 }
7031 }
7032 else if (inmenubar || !NILP (start))
7033 return 0;
7034 }
7035 else
7036 return 0; /* not a menu item */
7037
7038 /* If item string is not a string, evaluate it to get string.
7039 If we don't get a string, skip this item. */
7040 item_string = AREF (item_properties, ITEM_PROPERTY_NAME);
7041 if (!(STRINGP (item_string) || notreal))
7042 {
7043 item_string = menu_item_eval_property (item_string);
7044 if (!STRINGP (item_string))
7045 return 0;
7046 AREF (item_properties, ITEM_PROPERTY_NAME) = item_string;
7047 }
7048
7049 /* If got a filter apply it on definition. */
7050 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7051 if (!NILP (filter))
7052 {
7053 def = menu_item_eval_property (list2 (XCAR (filter),
7054 list2 (Qquote, def)));
7055
7056 AREF (item_properties, ITEM_PROPERTY_DEF) = def;
7057 }
7058
7059 /* Enable or disable selection of item. */
7060 tem = AREF (item_properties, ITEM_PROPERTY_ENABLE);
7061 if (!EQ (tem, Qt))
7062 {
7063 if (notreal)
7064 tem = Qt;
7065 else
7066 tem = menu_item_eval_property (tem);
7067 if (inmenubar && NILP (tem))
7068 return 0; /* Ignore disabled items in menu bar. */
7069 AREF (item_properties, ITEM_PROPERTY_ENABLE) = tem;
7070 }
7071
7072 /* If we got no definition, this item is just unselectable text which
7073 is OK in a submenu but not in the menubar. */
7074 if (NILP (def))
7075 return (inmenubar ? 0 : 1);
7076
7077 /* See if this is a separate pane or a submenu. */
7078 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7079 tem = get_keymap (def, 0, 1);
7080 /* For a subkeymap, just record its details and exit. */
7081 if (CONSP (tem))
7082 {
7083 AREF (item_properties, ITEM_PROPERTY_MAP) = tem;
7084 AREF (item_properties, ITEM_PROPERTY_DEF) = tem;
7085 return 1;
7086 }
7087
7088 /* At the top level in the menu bar, do likewise for commands also.
7089 The menu bar does not display equivalent key bindings anyway.
7090 ITEM_PROPERTY_DEF is already set up properly. */
7091 if (inmenubar > 0)
7092 return 1;
7093
7094 /* This is a command. See if there is an equivalent key binding. */
7095 if (NILP (cachelist))
7096 {
7097 /* We have to create a cachelist. */
7098 CHECK_IMPURE (start);
7099 XSETCDR (start, Fcons (Fcons (Qnil, Qnil), XCDR (start)));
7100 cachelist = XCAR (XCDR (start));
7101 newcache = 1;
7102 tem = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
7103 if (!NILP (keyhint))
7104 {
7105 XSETCAR (cachelist, XCAR (keyhint));
7106 newcache = 0;
7107 }
7108 else if (STRINGP (tem))
7109 {
7110 XSETCDR (cachelist, Fsubstitute_command_keys (tem));
7111 XSETCAR (cachelist, Qt);
7112 }
7113 }
7114
7115 tem = XCAR (cachelist);
7116 if (!EQ (tem, Qt))
7117 {
7118 int chkcache = 0;
7119 Lisp_Object prefix;
7120
7121 if (!NILP (tem))
7122 tem = Fkey_binding (tem, Qnil, Qnil);
7123
7124 prefix = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
7125 if (CONSP (prefix))
7126 {
7127 def = XCAR (prefix);
7128 prefix = XCDR (prefix);
7129 }
7130 else
7131 def = AREF (item_properties, ITEM_PROPERTY_DEF);
7132
7133 if (!update_menu_bindings)
7134 chkcache = 0;
7135 else if (NILP (XCAR (cachelist))) /* Have no saved key. */
7136 {
7137 if (newcache /* Always check first time. */
7138 /* Should we check everything when precomputing key
7139 bindings? */
7140 /* If something had no key binding before, don't recheck it
7141 because that is too slow--except if we have a list of
7142 rebound commands in Vdefine_key_rebound_commands, do
7143 recheck any command that appears in that list. */
7144 || (CONSP (Vdefine_key_rebound_commands)
7145 && !NILP (Fmemq (def, Vdefine_key_rebound_commands))))
7146 chkcache = 1;
7147 }
7148 /* We had a saved key. Is it still bound to the command? */
7149 else if (NILP (tem)
7150 || (!EQ (tem, def)
7151 /* If the command is an alias for another
7152 (such as lmenu.el set it up), check if the
7153 original command matches the cached command. */
7154 && !(SYMBOLP (def) && EQ (tem, XSYMBOL (def)->function))))
7155 chkcache = 1; /* Need to recompute key binding. */
7156
7157 if (chkcache)
7158 {
7159 /* Recompute equivalent key binding. If the command is an alias
7160 for another (such as lmenu.el set it up), see if the original
7161 command name has equivalent keys. Otherwise look up the
7162 specified command itself. We don't try both, because that
7163 makes lmenu menus slow. */
7164 if (SYMBOLP (def)
7165 && SYMBOLP (XSYMBOL (def)->function)
7166 && ! NILP (Fget (def, Qmenu_alias)))
7167 def = XSYMBOL (def)->function;
7168 tem = Fwhere_is_internal (def, Qnil, Qt, Qnil, Qt);
7169 XSETCAR (cachelist, tem);
7170 if (NILP (tem))
7171 {
7172 XSETCDR (cachelist, Qnil);
7173 chkcache = 0;
7174 }
7175 }
7176 else if (!NILP (keyhint) && !NILP (XCAR (cachelist)))
7177 {
7178 tem = XCAR (cachelist);
7179 chkcache = 1;
7180 }
7181
7182 newcache = chkcache;
7183 if (chkcache)
7184 {
7185 tem = Fkey_description (tem);
7186 if (CONSP (prefix))
7187 {
7188 if (STRINGP (XCAR (prefix)))
7189 tem = concat2 (XCAR (prefix), tem);
7190 if (STRINGP (XCDR (prefix)))
7191 tem = concat2 (tem, XCDR (prefix));
7192 }
7193 XSETCDR (cachelist, tem);
7194 }
7195 }
7196
7197 tem = XCDR (cachelist);
7198 if (newcache && !NILP (tem))
7199 {
7200 tem = concat3 (build_string (" ("), tem, build_string (")"));
7201 XSETCDR (cachelist, tem);
7202 }
7203
7204 /* If we only want to precompute equivalent key bindings, stop here. */
7205 if (notreal)
7206 return 1;
7207
7208 /* If we have an equivalent key binding, use that. */
7209 AREF (item_properties, ITEM_PROPERTY_KEYEQ) = tem;
7210
7211 /* Include this when menu help is implemented.
7212 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7213 if (!(NILP (tem) || STRINGP (tem)))
7214 {
7215 tem = menu_item_eval_property (tem);
7216 if (!STRINGP (tem))
7217 tem = Qnil;
7218 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7219 }
7220 */
7221
7222 /* Handle radio buttons or toggle boxes. */
7223 tem = AREF (item_properties, ITEM_PROPERTY_SELECTED);
7224 if (!NILP (tem))
7225 AREF (item_properties, ITEM_PROPERTY_SELECTED)
7226 = menu_item_eval_property (tem);
7227
7228 return 1;
7229 }
7230
7231
7232 \f
7233 /***********************************************************************
7234 Tool-bars
7235 ***********************************************************************/
7236
7237 /* A vector holding tool bar items while they are parsed in function
7238 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7239 in the vector. */
7240
7241 static Lisp_Object tool_bar_items_vector;
7242
7243 /* A vector holding the result of parse_tool_bar_item. Layout is like
7244 the one for a single item in tool_bar_items_vector. */
7245
7246 static Lisp_Object tool_bar_item_properties;
7247
7248 /* Next free index in tool_bar_items_vector. */
7249
7250 static int ntool_bar_items;
7251
7252 /* The symbols `tool-bar', and `:image'. */
7253
7254 extern Lisp_Object Qtool_bar;
7255 Lisp_Object QCimage;
7256
7257 /* Function prototypes. */
7258
7259 static void init_tool_bar_items P_ ((Lisp_Object));
7260 static void process_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
7261 static int parse_tool_bar_item P_ ((Lisp_Object, Lisp_Object));
7262 static void append_tool_bar_item P_ ((void));
7263
7264
7265 /* Return a vector of tool bar items for keymaps currently in effect.
7266 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7267 tool bar items found. */
7268
7269 Lisp_Object
7270 tool_bar_items (reuse, nitems)
7271 Lisp_Object reuse;
7272 int *nitems;
7273 {
7274 Lisp_Object *maps;
7275 int nmaps, i;
7276 Lisp_Object oquit;
7277 Lisp_Object *tmaps;
7278
7279 *nitems = 0;
7280
7281 /* In order to build the menus, we need to call the keymap
7282 accessors. They all call QUIT. But this function is called
7283 during redisplay, during which a quit is fatal. So inhibit
7284 quitting while building the menus. We do this instead of
7285 specbind because (1) errors will clear it anyway and (2) this
7286 avoids risk of specpdl overflow. */
7287 oquit = Vinhibit_quit;
7288 Vinhibit_quit = Qt;
7289
7290 /* Initialize tool_bar_items_vector and protect it from GC. */
7291 init_tool_bar_items (reuse);
7292
7293 /* Build list of keymaps in maps. Set nmaps to the number of maps
7294 to process. */
7295
7296 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7297 if (!NILP (Voverriding_local_map_menu_flag))
7298 {
7299 /* Yes, use them (if non-nil) as well as the global map. */
7300 maps = (Lisp_Object *) alloca (3 * sizeof (maps[0]));
7301 nmaps = 0;
7302 if (!NILP (current_kboard->Voverriding_terminal_local_map))
7303 maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
7304 if (!NILP (Voverriding_local_map))
7305 maps[nmaps++] = Voverriding_local_map;
7306 }
7307 else
7308 {
7309 /* No, so use major and minor mode keymaps and keymap property.
7310 Note that tool-bar bindings in the local-map and keymap
7311 properties may not work reliable, as they are only
7312 recognized when the tool-bar (or mode-line) is updated,
7313 which does not normally happen after every command. */
7314 Lisp_Object tem;
7315 int nminor;
7316 nminor = current_minor_maps (NULL, &tmaps);
7317 maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
7318 nmaps = 0;
7319 if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
7320 maps[nmaps++] = tem;
7321 bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
7322 nmaps += nminor;
7323 maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
7324 }
7325
7326 /* Add global keymap at the end. */
7327 maps[nmaps++] = current_global_map;
7328
7329 /* Process maps in reverse order and look up in each map the prefix
7330 key `tool-bar'. */
7331 for (i = nmaps - 1; i >= 0; --i)
7332 if (!NILP (maps[i]))
7333 {
7334 Lisp_Object keymap;
7335
7336 keymap = get_keymap (access_keymap (maps[i], Qtool_bar, 1, 0, 1), 0, 1);
7337 if (CONSP (keymap))
7338 {
7339 Lisp_Object tail;
7340
7341 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
7342 for (tail = keymap; CONSP (tail); tail = XCDR (tail))
7343 {
7344 Lisp_Object keydef = XCAR (tail);
7345 if (CONSP (keydef))
7346 process_tool_bar_item (XCAR (keydef), XCDR (keydef));
7347 }
7348 }
7349 }
7350
7351 Vinhibit_quit = oquit;
7352 *nitems = ntool_bar_items / TOOL_BAR_ITEM_NSLOTS;
7353 return tool_bar_items_vector;
7354 }
7355
7356
7357 /* Process the definition of KEY which is DEF. */
7358
7359 static void
7360 process_tool_bar_item (key, def)
7361 Lisp_Object key, def;
7362 {
7363 int i;
7364 extern Lisp_Object Qundefined;
7365 struct gcpro gcpro1, gcpro2;
7366
7367 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7368 eval. */
7369 GCPRO2 (key, def);
7370
7371 if (EQ (def, Qundefined))
7372 {
7373 /* If a map has an explicit `undefined' as definition,
7374 discard any previously made item. */
7375 for (i = 0; i < ntool_bar_items; i += TOOL_BAR_ITEM_NSLOTS)
7376 {
7377 Lisp_Object *v = XVECTOR (tool_bar_items_vector)->contents + i;
7378
7379 if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
7380 {
7381 if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
7382 bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
7383 ((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
7384 * sizeof (Lisp_Object)));
7385 ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
7386 break;
7387 }
7388 }
7389 }
7390 else if (parse_tool_bar_item (key, def))
7391 /* Append a new tool bar item to tool_bar_items_vector. Accept
7392 more than one definition for the same key. */
7393 append_tool_bar_item ();
7394
7395 UNGCPRO;
7396 }
7397
7398
7399 /* Parse a tool bar item specification ITEM for key KEY and return the
7400 result in tool_bar_item_properties. Value is zero if ITEM is
7401 invalid.
7402
7403 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7404
7405 CAPTION is the caption of the item, If it's not a string, it is
7406 evaluated to get a string.
7407
7408 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7409 as binding are currently ignored.
7410
7411 The following properties are recognized:
7412
7413 - `:enable FORM'.
7414
7415 FORM is evaluated and specifies whether the tool bar item is
7416 enabled or disabled.
7417
7418 - `:visible FORM'
7419
7420 FORM is evaluated and specifies whether the tool bar item is visible.
7421
7422 - `:filter FUNCTION'
7423
7424 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
7425 result is stored as the new binding.
7426
7427 - `:button (TYPE SELECTED)'
7428
7429 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
7430 and specifies whether the button is selected (pressed) or not.
7431
7432 - `:image IMAGES'
7433
7434 IMAGES is either a single image specification or a vector of four
7435 image specifications. See enum tool_bar_item_images.
7436
7437 - `:help HELP-STRING'.
7438
7439 Gives a help string to display for the tool bar item. */
7440
7441 static int
7442 parse_tool_bar_item (key, item)
7443 Lisp_Object key, item;
7444 {
7445 /* Access slot with index IDX of vector tool_bar_item_properties. */
7446 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
7447
7448 Lisp_Object filter = Qnil;
7449 Lisp_Object caption;
7450 int i;
7451
7452 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
7453 Rule out items that aren't lists, don't start with
7454 `menu-item' or whose rest following `tool-bar-item' is not a
7455 list. */
7456 if (!CONSP (item)
7457 || !EQ (XCAR (item), Qmenu_item)
7458 || (item = XCDR (item),
7459 !CONSP (item)))
7460 return 0;
7461
7462 /* Create tool_bar_item_properties vector if necessary. Reset it to
7463 defaults. */
7464 if (VECTORP (tool_bar_item_properties))
7465 {
7466 for (i = 0; i < TOOL_BAR_ITEM_NSLOTS; ++i)
7467 PROP (i) = Qnil;
7468 }
7469 else
7470 tool_bar_item_properties
7471 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS), Qnil);
7472
7473 /* Set defaults. */
7474 PROP (TOOL_BAR_ITEM_KEY) = key;
7475 PROP (TOOL_BAR_ITEM_ENABLED_P) = Qt;
7476
7477 /* Get the caption of the item. If the caption is not a string,
7478 evaluate it to get a string. If we don't get a string, skip this
7479 item. */
7480 caption = XCAR (item);
7481 if (!STRINGP (caption))
7482 {
7483 caption = menu_item_eval_property (caption);
7484 if (!STRINGP (caption))
7485 return 0;
7486 }
7487 PROP (TOOL_BAR_ITEM_CAPTION) = caption;
7488
7489 /* Give up if rest following the caption is not a list. */
7490 item = XCDR (item);
7491 if (!CONSP (item))
7492 return 0;
7493
7494 /* Store the binding. */
7495 PROP (TOOL_BAR_ITEM_BINDING) = XCAR (item);
7496 item = XCDR (item);
7497
7498 /* Ignore cached key binding, if any. */
7499 if (CONSP (item) && CONSP (XCAR (item)))
7500 item = XCDR (item);
7501
7502 /* Process the rest of the properties. */
7503 for (; CONSP (item) && CONSP (XCDR (item)); item = XCDR (XCDR (item)))
7504 {
7505 Lisp_Object key, value;
7506
7507 key = XCAR (item);
7508 value = XCAR (XCDR (item));
7509
7510 if (EQ (key, QCenable))
7511 /* `:enable FORM'. */
7512 PROP (TOOL_BAR_ITEM_ENABLED_P) = value;
7513 else if (EQ (key, QCvisible))
7514 {
7515 /* `:visible FORM'. If got a visible property and that
7516 evaluates to nil then ignore this item. */
7517 if (NILP (menu_item_eval_property (value)))
7518 return 0;
7519 }
7520 else if (EQ (key, QChelp))
7521 /* `:help HELP-STRING'. */
7522 PROP (TOOL_BAR_ITEM_HELP) = value;
7523 else if (EQ (key, QCfilter))
7524 /* ':filter FORM'. */
7525 filter = value;
7526 else if (EQ (key, QCbutton) && CONSP (value))
7527 {
7528 /* `:button (TYPE . SELECTED)'. */
7529 Lisp_Object type, selected;
7530
7531 type = XCAR (value);
7532 selected = XCDR (value);
7533 if (EQ (type, QCtoggle) || EQ (type, QCradio))
7534 {
7535 PROP (TOOL_BAR_ITEM_SELECTED_P) = selected;
7536 PROP (TOOL_BAR_ITEM_TYPE) = type;
7537 }
7538 }
7539 else if (EQ (key, QCimage)
7540 && (CONSP (value)
7541 || (VECTORP (value) && XVECTOR (value)->size == 4)))
7542 /* Value is either a single image specification or a vector
7543 of 4 such specifications for the different button states. */
7544 PROP (TOOL_BAR_ITEM_IMAGES) = value;
7545 }
7546
7547 /* If got a filter apply it on binding. */
7548 if (!NILP (filter))
7549 PROP (TOOL_BAR_ITEM_BINDING)
7550 = menu_item_eval_property (list2 (filter,
7551 list2 (Qquote,
7552 PROP (TOOL_BAR_ITEM_BINDING))));
7553
7554 /* See if the binding is a keymap. Give up if it is. */
7555 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING), 0, 1)))
7556 return 0;
7557
7558 /* Enable or disable selection of item. */
7559 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P), Qt))
7560 PROP (TOOL_BAR_ITEM_ENABLED_P)
7561 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P));
7562
7563 /* Handle radio buttons or toggle boxes. */
7564 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P)))
7565 PROP (TOOL_BAR_ITEM_SELECTED_P)
7566 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P));
7567
7568 return 1;
7569
7570 #undef PROP
7571 }
7572
7573
7574 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7575 that can be reused. */
7576
7577 static void
7578 init_tool_bar_items (reuse)
7579 Lisp_Object reuse;
7580 {
7581 if (VECTORP (reuse))
7582 tool_bar_items_vector = reuse;
7583 else
7584 tool_bar_items_vector = Fmake_vector (make_number (64), Qnil);
7585 ntool_bar_items = 0;
7586 }
7587
7588
7589 /* Append parsed tool bar item properties from
7590 tool_bar_item_properties */
7591
7592 static void
7593 append_tool_bar_item ()
7594 {
7595 Lisp_Object *to, *from;
7596
7597 /* Enlarge tool_bar_items_vector if necessary. */
7598 if (ntool_bar_items + TOOL_BAR_ITEM_NSLOTS
7599 >= XVECTOR (tool_bar_items_vector)->size)
7600 {
7601 Lisp_Object new_vector;
7602 int old_size = XVECTOR (tool_bar_items_vector)->size;
7603
7604 new_vector = Fmake_vector (make_number (2 * old_size), Qnil);
7605 bcopy (XVECTOR (tool_bar_items_vector)->contents,
7606 XVECTOR (new_vector)->contents,
7607 old_size * sizeof (Lisp_Object));
7608 tool_bar_items_vector = new_vector;
7609 }
7610
7611 /* Append entries from tool_bar_item_properties to the end of
7612 tool_bar_items_vector. */
7613 to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
7614 from = XVECTOR (tool_bar_item_properties)->contents;
7615 bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
7616 ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
7617 }
7618
7619
7620
7621
7622 \f
7623 /* Read a character using menus based on maps in the array MAPS.
7624 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7625 Return t if we displayed a menu but the user rejected it.
7626
7627 PREV_EVENT is the previous input event, or nil if we are reading
7628 the first event of a key sequence.
7629
7630 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7631 if we used a mouse menu to read the input, or zero otherwise. If
7632 USED_MOUSE_MENU is null, we don't dereference it.
7633
7634 The prompting is done based on the prompt-string of the map
7635 and the strings associated with various map elements.
7636
7637 This can be done with X menus or with menus put in the minibuf.
7638 These are done in different ways, depending on how the input will be read.
7639 Menus using X are done after auto-saving in read-char, getting the input
7640 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7641 and do auto-saving in the inner call of read_char. */
7642
7643 static Lisp_Object
7644 read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
7645 int nmaps;
7646 Lisp_Object *maps;
7647 Lisp_Object prev_event;
7648 int *used_mouse_menu;
7649 {
7650 int mapno;
7651 register Lisp_Object name;
7652
7653 if (used_mouse_menu)
7654 *used_mouse_menu = 0;
7655
7656 /* Use local over global Menu maps */
7657
7658 if (! menu_prompting)
7659 return Qnil;
7660
7661 /* Optionally disregard all but the global map. */
7662 if (inhibit_local_menu_bar_menus)
7663 {
7664 maps += (nmaps - 1);
7665 nmaps = 1;
7666 }
7667
7668 /* Get the menu name from the first map that has one (a prompt string). */
7669 for (mapno = 0; mapno < nmaps; mapno++)
7670 {
7671 name = Fkeymap_prompt (maps[mapno]);
7672 if (!NILP (name))
7673 break;
7674 }
7675
7676 /* If we don't have any menus, just read a character normally. */
7677 if (!STRINGP (name))
7678 return Qnil;
7679
7680 #ifdef HAVE_MENUS
7681 /* If we got to this point via a mouse click,
7682 use a real menu for mouse selection. */
7683 if (EVENT_HAS_PARAMETERS (prev_event)
7684 && !EQ (XCAR (prev_event), Qmenu_bar)
7685 && !EQ (XCAR (prev_event), Qtool_bar))
7686 {
7687 /* Display the menu and get the selection. */
7688 Lisp_Object *realmaps
7689 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
7690 Lisp_Object value;
7691 int nmaps1 = 0;
7692
7693 /* Use the maps that are not nil. */
7694 for (mapno = 0; mapno < nmaps; mapno++)
7695 if (!NILP (maps[mapno]))
7696 realmaps[nmaps1++] = maps[mapno];
7697
7698 value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
7699 if (CONSP (value))
7700 {
7701 Lisp_Object tem;
7702
7703 record_menu_key (XCAR (value));
7704
7705 /* If we got multiple events, unread all but
7706 the first.
7707 There is no way to prevent those unread events
7708 from showing up later in last_nonmenu_event.
7709 So turn symbol and integer events into lists,
7710 to indicate that they came from a mouse menu,
7711 so that when present in last_nonmenu_event
7712 they won't confuse things. */
7713 for (tem = XCDR (value); !NILP (tem); tem = XCDR (tem))
7714 {
7715 record_menu_key (XCAR (tem));
7716 if (SYMBOLP (XCAR (tem))
7717 || INTEGERP (XCAR (tem)))
7718 XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
7719 }
7720
7721 /* If we got more than one event, put all but the first
7722 onto this list to be read later.
7723 Return just the first event now. */
7724 Vunread_command_events
7725 = nconc2 (XCDR (value), Vunread_command_events);
7726 value = XCAR (value);
7727 }
7728 else if (NILP (value))
7729 value = Qt;
7730 if (used_mouse_menu)
7731 *used_mouse_menu = 1;
7732 return value;
7733 }
7734 #endif /* HAVE_MENUS */
7735 return Qnil ;
7736 }
7737
7738 /* Buffer in use so far for the minibuf prompts for menu keymaps.
7739 We make this bigger when necessary, and never free it. */
7740 static char *read_char_minibuf_menu_text;
7741 /* Size of that buffer. */
7742 static int read_char_minibuf_menu_width;
7743
7744 static Lisp_Object
7745 read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
7746 int commandflag ;
7747 int nmaps;
7748 Lisp_Object *maps;
7749 {
7750 int mapno;
7751 register Lisp_Object name;
7752 int nlength;
7753 int width = FRAME_WIDTH (SELECTED_FRAME ()) - 4;
7754 int idx = -1;
7755 int nobindings = 1;
7756 Lisp_Object rest, vector;
7757 char *menu;
7758
7759 vector = Qnil;
7760 name = Qnil;
7761
7762 if (! menu_prompting)
7763 return Qnil;
7764
7765 /* Make sure we have a big enough buffer for the menu text. */
7766 if (read_char_minibuf_menu_text == 0)
7767 {
7768 read_char_minibuf_menu_width = width + 4;
7769 read_char_minibuf_menu_text = (char *) xmalloc (width + 4);
7770 }
7771 else if (width + 4 > read_char_minibuf_menu_width)
7772 {
7773 read_char_minibuf_menu_width = width + 4;
7774 read_char_minibuf_menu_text
7775 = (char *) xrealloc (read_char_minibuf_menu_text, width + 4);
7776 }
7777 menu = read_char_minibuf_menu_text;
7778
7779 /* Get the menu name from the first map that has one (a prompt string). */
7780 for (mapno = 0; mapno < nmaps; mapno++)
7781 {
7782 name = Fkeymap_prompt (maps[mapno]);
7783 if (!NILP (name))
7784 break;
7785 }
7786
7787 /* If we don't have any menus, just read a character normally. */
7788 if (!STRINGP (name))
7789 return Qnil;
7790
7791 /* Prompt string always starts with map's prompt, and a space. */
7792 strcpy (menu, SDATA (name));
7793 nlength = SBYTES (name);
7794 menu[nlength++] = ':';
7795 menu[nlength++] = ' ';
7796 menu[nlength] = 0;
7797
7798 /* Start prompting at start of first map. */
7799 mapno = 0;
7800 rest = maps[mapno];
7801
7802 /* Present the documented bindings, a line at a time. */
7803 while (1)
7804 {
7805 int notfirst = 0;
7806 int i = nlength;
7807 Lisp_Object obj;
7808 int ch;
7809 Lisp_Object orig_defn_macro;
7810
7811 /* Loop over elements of map. */
7812 while (i < width)
7813 {
7814 Lisp_Object elt;
7815
7816 /* If reached end of map, start at beginning of next map. */
7817 if (NILP (rest))
7818 {
7819 mapno++;
7820 /* At end of last map, wrap around to first map if just starting,
7821 or end this line if already have something on it. */
7822 if (mapno == nmaps)
7823 {
7824 mapno = 0;
7825 if (notfirst || nobindings) break;
7826 }
7827 rest = maps[mapno];
7828 }
7829
7830 /* Look at the next element of the map. */
7831 if (idx >= 0)
7832 elt = XVECTOR (vector)->contents[idx];
7833 else
7834 elt = Fcar_safe (rest);
7835
7836 if (idx < 0 && VECTORP (elt))
7837 {
7838 /* If we found a dense table in the keymap,
7839 advanced past it, but start scanning its contents. */
7840 rest = Fcdr_safe (rest);
7841 vector = elt;
7842 idx = 0;
7843 }
7844 else
7845 {
7846 /* An ordinary element. */
7847 Lisp_Object event, tem;
7848
7849 if (idx < 0)
7850 {
7851 event = Fcar_safe (elt); /* alist */
7852 elt = Fcdr_safe (elt);
7853 }
7854 else
7855 {
7856 XSETINT (event, idx); /* vector */
7857 }
7858
7859 /* Ignore the element if it has no prompt string. */
7860 if (INTEGERP (event) && parse_menu_item (elt, 0, -1))
7861 {
7862 /* 1 if the char to type matches the string. */
7863 int char_matches;
7864 Lisp_Object upcased_event, downcased_event;
7865 Lisp_Object desc = Qnil;
7866 Lisp_Object s
7867 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_NAME];
7868
7869 upcased_event = Fupcase (event);
7870 downcased_event = Fdowncase (event);
7871 char_matches = (XINT (upcased_event) == SREF (s, 0)
7872 || XINT (downcased_event) == SREF (s, 0));
7873 if (! char_matches)
7874 desc = Fsingle_key_description (event, Qnil);
7875
7876 #if 0 /* It is redundant to list the equivalent key bindings because
7877 the prefix is what the user has already typed. */
7878 tem
7879 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
7880 if (!NILP (tem))
7881 /* Insert equivalent keybinding. */
7882 s = concat2 (s, tem);
7883 #endif
7884 tem
7885 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
7886 if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
7887 {
7888 /* Insert button prefix. */
7889 Lisp_Object selected
7890 = XVECTOR (item_properties)->contents[ITEM_PROPERTY_SELECTED];
7891 if (EQ (tem, QCradio))
7892 tem = build_string (NILP (selected) ? "(*) " : "( ) ");
7893 else
7894 tem = build_string (NILP (selected) ? "[X] " : "[ ] ");
7895 s = concat2 (tem, s);
7896 }
7897
7898
7899 /* If we have room for the prompt string, add it to this line.
7900 If this is the first on the line, always add it. */
7901 if ((SCHARS (s) + i + 2
7902 + (char_matches ? 0 : SCHARS (desc) + 3))
7903 < width
7904 || !notfirst)
7905 {
7906 int thiswidth;
7907
7908 /* Punctuate between strings. */
7909 if (notfirst)
7910 {
7911 strcpy (menu + i, ", ");
7912 i += 2;
7913 }
7914 notfirst = 1;
7915 nobindings = 0 ;
7916
7917 /* If the char to type doesn't match the string's
7918 first char, explicitly show what char to type. */
7919 if (! char_matches)
7920 {
7921 /* Add as much of string as fits. */
7922 thiswidth = SCHARS (desc);
7923 if (thiswidth + i > width)
7924 thiswidth = width - i;
7925 bcopy (SDATA (desc), menu + i, thiswidth);
7926 i += thiswidth;
7927 strcpy (menu + i, " = ");
7928 i += 3;
7929 }
7930
7931 /* Add as much of string as fits. */
7932 thiswidth = SCHARS (s);
7933 if (thiswidth + i > width)
7934 thiswidth = width - i;
7935 bcopy (SDATA (s), menu + i, thiswidth);
7936 i += thiswidth;
7937 menu[i] = 0;
7938 }
7939 else
7940 {
7941 /* If this element does not fit, end the line now,
7942 and save the element for the next line. */
7943 strcpy (menu + i, "...");
7944 break;
7945 }
7946 }
7947
7948 /* Move past this element. */
7949 if (idx >= 0 && idx + 1 >= XVECTOR (vector)->size)
7950 /* Handle reaching end of dense table. */
7951 idx = -1;
7952 if (idx >= 0)
7953 idx++;
7954 else
7955 rest = Fcdr_safe (rest);
7956 }
7957 }
7958
7959 /* Prompt with that and read response. */
7960 message2_nolog (menu, strlen (menu),
7961 ! NILP (current_buffer->enable_multibyte_characters));
7962
7963 /* Make believe its not a keyboard macro in case the help char
7964 is pressed. Help characters are not recorded because menu prompting
7965 is not used on replay.
7966 */
7967 orig_defn_macro = current_kboard->defining_kbd_macro;
7968 current_kboard->defining_kbd_macro = Qnil;
7969 do
7970 obj = read_char (commandflag, 0, 0, Qt, 0);
7971 while (BUFFERP (obj));
7972 current_kboard->defining_kbd_macro = orig_defn_macro;
7973
7974 if (!INTEGERP (obj))
7975 return obj;
7976 else
7977 ch = XINT (obj);
7978
7979 if (! EQ (obj, menu_prompt_more_char)
7980 && (!INTEGERP (menu_prompt_more_char)
7981 || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
7982 {
7983 if (!NILP (current_kboard->defining_kbd_macro))
7984 store_kbd_macro_char (obj);
7985 return obj;
7986 }
7987 /* Help char - go round again */
7988 }
7989 }
7990 \f
7991 /* Reading key sequences. */
7992
7993 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
7994 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
7995 keymap, or nil otherwise. Return the index of the first keymap in
7996 which KEY has any binding, or NMAPS if no map has a binding.
7997
7998 If KEY is a meta ASCII character, treat it like meta-prefix-char
7999 followed by the corresponding non-meta character. Keymaps in
8000 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8001 NEXT.
8002
8003 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8004 unmodified.
8005
8006 NEXT may be the same array as CURRENT. */
8007
8008 static int
8009 follow_key (key, nmaps, current, defs, next)
8010 Lisp_Object key;
8011 Lisp_Object *current, *defs, *next;
8012 int nmaps;
8013 {
8014 int i, first_binding;
8015 int did_meta = 0;
8016
8017 first_binding = nmaps;
8018 for (i = nmaps - 1; i >= 0; i--)
8019 {
8020 if (! NILP (current[i]))
8021 {
8022 Lisp_Object map;
8023 if (did_meta)
8024 map = defs[i];
8025 else
8026 map = current[i];
8027
8028 defs[i] = access_keymap (map, key, 1, 0, 1);
8029 if (! NILP (defs[i]))
8030 first_binding = i;
8031 }
8032 else
8033 defs[i] = Qnil;
8034 }
8035
8036 /* Given the set of bindings we've found, produce the next set of maps. */
8037 if (first_binding < nmaps)
8038 for (i = 0; i < nmaps; i++)
8039 next[i] = NILP (defs[i]) ? Qnil : get_keymap (defs[i], 0, 1);
8040
8041 return first_binding;
8042 }
8043
8044 /* Structure used to keep track of partial application of key remapping
8045 such as Vfunction_key_map and Vkey_translation_map. */
8046 typedef struct keyremap
8047 {
8048 Lisp_Object map;
8049 int start, end;
8050 } keyremap;
8051
8052
8053 /* Read a sequence of keys that ends with a non prefix character,
8054 storing it in KEYBUF, a buffer of size BUFSIZE.
8055 Prompt with PROMPT.
8056 Return the length of the key sequence stored.
8057 Return -1 if the user rejected a command menu.
8058
8059 Echo starting immediately unless `prompt' is 0.
8060
8061 Where a key sequence ends depends on the currently active keymaps.
8062 These include any minor mode keymaps active in the current buffer,
8063 the current buffer's local map, and the global map.
8064
8065 If a key sequence has no other bindings, we check Vfunction_key_map
8066 to see if some trailing subsequence might be the beginning of a
8067 function key's sequence. If so, we try to read the whole function
8068 key, and substitute its symbolic name into the key sequence.
8069
8070 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8071 `double-' events into similar click events, if that would make them
8072 bound. We try to turn `triple-' events first into `double-' events,
8073 then into clicks.
8074
8075 If we get a mouse click in a mode line, vertical divider, or other
8076 non-text area, we treat the click as if it were prefixed by the
8077 symbol denoting that area - `mode-line', `vertical-line', or
8078 whatever.
8079
8080 If the sequence starts with a mouse click, we read the key sequence
8081 with respect to the buffer clicked on, not the current buffer.
8082
8083 If the user switches frames in the midst of a key sequence, we put
8084 off the switch-frame event until later; the next call to
8085 read_char will return it.
8086
8087 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8088 from the selected window's buffer. */
8089
8090 static int
8091 read_key_sequence (keybuf, bufsize, prompt, dont_downcase_last,
8092 can_return_switch_frame, fix_current_buffer)
8093 Lisp_Object *keybuf;
8094 int bufsize;
8095 Lisp_Object prompt;
8096 int dont_downcase_last;
8097 int can_return_switch_frame;
8098 int fix_current_buffer;
8099 {
8100 volatile Lisp_Object from_string;
8101 volatile int count = SPECPDL_INDEX ();
8102
8103 /* How many keys there are in the current key sequence. */
8104 volatile int t;
8105
8106 /* The length of the echo buffer when we started reading, and
8107 the length of this_command_keys when we started reading. */
8108 volatile int echo_start;
8109 volatile int keys_start;
8110
8111 /* The number of keymaps we're scanning right now, and the number of
8112 keymaps we have allocated space for. */
8113 volatile int nmaps;
8114 volatile int nmaps_allocated = 0;
8115
8116 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8117 the current keymaps. */
8118 Lisp_Object *volatile defs = NULL;
8119
8120 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8121 in the current keymaps, or nil where it is not a prefix. */
8122 Lisp_Object *volatile submaps = NULL;
8123
8124 /* The local map to start out with at start of key sequence. */
8125 volatile Lisp_Object orig_local_map;
8126
8127 /* The map from the `keymap' property to start out with at start of
8128 key sequence. */
8129 volatile Lisp_Object orig_keymap;
8130
8131 /* 1 if we have already considered switching to the local-map property
8132 of the place where a mouse click occurred. */
8133 volatile int localized_local_map = 0;
8134
8135 /* The index in defs[] of the first keymap that has a binding for
8136 this key sequence. In other words, the lowest i such that
8137 defs[i] is non-nil. */
8138 volatile int first_binding;
8139 /* Index of the first key that has no binding.
8140 It is useless to try fkey.start larger than that. */
8141 volatile int first_unbound;
8142
8143 /* If t < mock_input, then KEYBUF[t] should be read as the next
8144 input key.
8145
8146 We use this to recover after recognizing a function key. Once we
8147 realize that a suffix of the current key sequence is actually a
8148 function key's escape sequence, we replace the suffix with the
8149 function key's binding from Vfunction_key_map. Now keybuf
8150 contains a new and different key sequence, so the echo area,
8151 this_command_keys, and the submaps and defs arrays are wrong. In
8152 this situation, we set mock_input to t, set t to 0, and jump to
8153 restart_sequence; the loop will read keys from keybuf up until
8154 mock_input, thus rebuilding the state; and then it will resume
8155 reading characters from the keyboard. */
8156 volatile int mock_input = 0;
8157
8158 /* If the sequence is unbound in submaps[], then
8159 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8160 and fkey.map is its binding.
8161
8162 These might be > t, indicating that all function key scanning
8163 should hold off until t reaches them. We do this when we've just
8164 recognized a function key, to avoid searching for the function
8165 key's again in Vfunction_key_map. */
8166 volatile keyremap fkey;
8167
8168 /* Likewise, for key_translation_map. */
8169 volatile keyremap keytran;
8170
8171 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
8172 we put it off for later. While we're reading, we keep the event here. */
8173 volatile Lisp_Object delayed_switch_frame;
8174
8175 /* See the comment below... */
8176 #if defined (GOBBLE_FIRST_EVENT)
8177 Lisp_Object first_event;
8178 #endif
8179
8180 volatile Lisp_Object original_uppercase;
8181 volatile int original_uppercase_position = -1;
8182
8183 /* Gets around Microsoft compiler limitations. */
8184 int dummyflag = 0;
8185
8186 struct buffer *starting_buffer;
8187
8188 /* List of events for which a fake prefix key has been generated. */
8189 volatile Lisp_Object fake_prefixed_keys = Qnil;
8190
8191 #if defined (GOBBLE_FIRST_EVENT)
8192 int junk;
8193 #endif
8194
8195 struct gcpro gcpro1;
8196
8197 GCPRO1 (fake_prefixed_keys);
8198 raw_keybuf_count = 0;
8199
8200 last_nonmenu_event = Qnil;
8201
8202 delayed_switch_frame = Qnil;
8203 fkey.map = Vfunction_key_map;
8204 keytran.map = Vkey_translation_map;
8205 /* If there is no translation-map, turn off scanning. */
8206 fkey.start = fkey.end = KEYMAPP (fkey.map) ? 0 : bufsize + 1;
8207 keytran.start = keytran.end = KEYMAPP (keytran.map) ? 0 : bufsize + 1;
8208
8209 if (INTERACTIVE)
8210 {
8211 if (!NILP (prompt))
8212 echo_prompt (prompt);
8213 else if (cursor_in_echo_area
8214 && (FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
8215 && NILP (Fzerop (Vecho_keystrokes)))
8216 /* This doesn't put in a dash if the echo buffer is empty, so
8217 you don't always see a dash hanging out in the minibuffer. */
8218 echo_dash ();
8219 }
8220
8221 /* Record the initial state of the echo area and this_command_keys;
8222 we will need to restore them if we replay a key sequence. */
8223 if (INTERACTIVE)
8224 echo_start = echo_length ();
8225 keys_start = this_command_key_count;
8226 this_single_command_key_start = keys_start;
8227
8228 #if defined (GOBBLE_FIRST_EVENT)
8229 /* This doesn't quite work, because some of the things that read_char
8230 does cannot safely be bypassed. It seems too risky to try to make
8231 this work right. */
8232
8233 /* Read the first char of the sequence specially, before setting
8234 up any keymaps, in case a filter runs and switches buffers on us. */
8235 first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
8236 &junk);
8237 #endif /* GOBBLE_FIRST_EVENT */
8238
8239 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
8240 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
8241 from_string = Qnil;
8242
8243 /* We jump here when the key sequence has been thoroughly changed, and
8244 we need to rescan it starting from the beginning. When we jump here,
8245 keybuf[0..mock_input] holds the sequence we should reread. */
8246 replay_sequence:
8247
8248 starting_buffer = current_buffer;
8249 first_unbound = bufsize + 1;
8250
8251 /* Build our list of keymaps.
8252 If we recognize a function key and replace its escape sequence in
8253 keybuf with its symbol, or if the sequence starts with a mouse
8254 click and we need to switch buffers, we jump back here to rebuild
8255 the initial keymaps from the current buffer. */
8256 nmaps = 0;
8257
8258 if (!NILP (current_kboard->Voverriding_terminal_local_map)
8259 || !NILP (Voverriding_local_map))
8260 {
8261 if (3 > nmaps_allocated)
8262 {
8263 submaps = (Lisp_Object *) alloca (3 * sizeof (submaps[0]));
8264 defs = (Lisp_Object *) alloca (3 * sizeof (defs[0]));
8265 nmaps_allocated = 3;
8266 }
8267 if (!NILP (current_kboard->Voverriding_terminal_local_map))
8268 submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
8269 if (!NILP (Voverriding_local_map))
8270 submaps[nmaps++] = Voverriding_local_map;
8271 }
8272 else
8273 {
8274 int nminor;
8275 int total;
8276 Lisp_Object *maps;
8277
8278 nminor = current_minor_maps (0, &maps);
8279 total = nminor + (!NILP (orig_keymap) ? 3 : 2);
8280
8281 if (total > nmaps_allocated)
8282 {
8283 submaps = (Lisp_Object *) alloca (total * sizeof (submaps[0]));
8284 defs = (Lisp_Object *) alloca (total * sizeof (defs[0]));
8285 nmaps_allocated = total;
8286 }
8287
8288 if (!NILP (orig_keymap))
8289 submaps[nmaps++] = orig_keymap;
8290
8291 bcopy (maps, (void *) (submaps + nmaps),
8292 nminor * sizeof (submaps[0]));
8293
8294 nmaps += nminor;
8295
8296 submaps[nmaps++] = orig_local_map;
8297 }
8298 submaps[nmaps++] = current_global_map;
8299
8300 /* Find an accurate initial value for first_binding. */
8301 for (first_binding = 0; first_binding < nmaps; first_binding++)
8302 if (! NILP (submaps[first_binding]))
8303 break;
8304
8305 /* Start from the beginning in keybuf. */
8306 t = 0;
8307
8308 /* These are no-ops the first time through, but if we restart, they
8309 revert the echo area and this_command_keys to their original state. */
8310 this_command_key_count = keys_start;
8311 if (INTERACTIVE && t < mock_input)
8312 echo_truncate (echo_start);
8313
8314 /* If the best binding for the current key sequence is a keymap, or
8315 we may be looking at a function key's escape sequence, keep on
8316 reading. */
8317 while (first_binding < nmaps
8318 /* Keep reading as long as there's a prefix binding. */
8319 ? !NILP (submaps[first_binding])
8320 /* Don't return in the middle of a possible function key sequence,
8321 if the only bindings we found were via case conversion.
8322 Thus, if ESC O a has a function-key-map translation
8323 and ESC o has a binding, don't return after ESC O,
8324 so that we can translate ESC O plus the next character. */
8325 : (fkey.start < t || keytran.start < t))
8326 {
8327 Lisp_Object key;
8328 int used_mouse_menu = 0;
8329
8330 /* Where the last real key started. If we need to throw away a
8331 key that has expanded into more than one element of keybuf
8332 (say, a mouse click on the mode line which is being treated
8333 as [mode-line (mouse-...)], then we backtrack to this point
8334 of keybuf. */
8335 volatile int last_real_key_start;
8336
8337 /* These variables are analogous to echo_start and keys_start;
8338 while those allow us to restart the entire key sequence,
8339 echo_local_start and keys_local_start allow us to throw away
8340 just one key. */
8341 volatile int echo_local_start, keys_local_start, local_first_binding;
8342
8343 /* key-translation-map is applied *after* function-key-map. */
8344 eassert (keytran.end <= fkey.start);
8345
8346 if (first_unbound < fkey.start && first_unbound < keytran.start)
8347 { /* The prefix upto first_unbound has no binding and has
8348 no translation left to do either, so we know it's unbound.
8349 If we don't stop now, we risk staying here indefinitely
8350 (if the user keeps entering fkey or keytran prefixes
8351 like C-c ESC ESC ESC ESC ...) */
8352 int i;
8353 for (i = first_unbound + 1; i < t; i++)
8354 keybuf[i - first_unbound - 1] = keybuf[i];
8355 mock_input = t - first_unbound - 1;
8356 fkey.end = fkey.start -= first_unbound + 1;
8357 fkey.map = Vfunction_key_map;
8358 keytran.end = keytran.start -= first_unbound + 1;
8359 keytran.map = Vkey_translation_map;
8360 goto replay_sequence;
8361 }
8362
8363 if (t >= bufsize)
8364 error ("Key sequence too long");
8365
8366 if (INTERACTIVE)
8367 echo_local_start = echo_length ();
8368 keys_local_start = this_command_key_count;
8369 local_first_binding = first_binding;
8370
8371 replay_key:
8372 /* These are no-ops, unless we throw away a keystroke below and
8373 jumped back up to replay_key; in that case, these restore the
8374 variables to their original state, allowing us to replay the
8375 loop. */
8376 if (INTERACTIVE && t < mock_input)
8377 echo_truncate (echo_local_start);
8378 this_command_key_count = keys_local_start;
8379 first_binding = local_first_binding;
8380
8381 /* By default, assume each event is "real". */
8382 last_real_key_start = t;
8383
8384 /* Does mock_input indicate that we are re-reading a key sequence? */
8385 if (t < mock_input)
8386 {
8387 key = keybuf[t];
8388 add_command_key (key);
8389 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
8390 && NILP (Fzerop (Vecho_keystrokes)))
8391 echo_char (key);
8392 }
8393
8394 /* If not, we should actually read a character. */
8395 else
8396 {
8397 {
8398 #ifdef MULTI_KBOARD
8399 KBOARD *interrupted_kboard = current_kboard;
8400 struct frame *interrupted_frame = SELECTED_FRAME ();
8401 if (setjmp (wrong_kboard_jmpbuf))
8402 {
8403 if (!NILP (delayed_switch_frame))
8404 {
8405 interrupted_kboard->kbd_queue
8406 = Fcons (delayed_switch_frame,
8407 interrupted_kboard->kbd_queue);
8408 delayed_switch_frame = Qnil;
8409 }
8410 while (t > 0)
8411 interrupted_kboard->kbd_queue
8412 = Fcons (keybuf[--t], interrupted_kboard->kbd_queue);
8413
8414 /* If the side queue is non-empty, ensure it begins with a
8415 switch-frame, so we'll replay it in the right context. */
8416 if (CONSP (interrupted_kboard->kbd_queue)
8417 && (key = XCAR (interrupted_kboard->kbd_queue),
8418 !(EVENT_HAS_PARAMETERS (key)
8419 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)),
8420 Qswitch_frame))))
8421 {
8422 Lisp_Object frame;
8423 XSETFRAME (frame, interrupted_frame);
8424 interrupted_kboard->kbd_queue
8425 = Fcons (make_lispy_switch_frame (frame),
8426 interrupted_kboard->kbd_queue);
8427 }
8428 mock_input = 0;
8429 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
8430 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
8431 goto replay_sequence;
8432 }
8433 #endif
8434 key = read_char (NILP (prompt), nmaps,
8435 (Lisp_Object *) submaps, last_nonmenu_event,
8436 &used_mouse_menu);
8437 }
8438
8439 /* read_char returns t when it shows a menu and the user rejects it.
8440 Just return -1. */
8441 if (EQ (key, Qt))
8442 {
8443 unbind_to (count, Qnil);
8444 UNGCPRO;
8445 return -1;
8446 }
8447
8448 /* read_char returns -1 at the end of a macro.
8449 Emacs 18 handles this by returning immediately with a
8450 zero, so that's what we'll do. */
8451 if (INTEGERP (key) && XINT (key) == -1)
8452 {
8453 t = 0;
8454 /* The Microsoft C compiler can't handle the goto that
8455 would go here. */
8456 dummyflag = 1;
8457 break;
8458 }
8459
8460 /* If the current buffer has been changed from under us, the
8461 keymap may have changed, so replay the sequence. */
8462 if (BUFFERP (key))
8463 {
8464 EMACS_TIME initial_idleness_start_time;
8465 EMACS_SET_SECS_USECS (initial_idleness_start_time,
8466 EMACS_SECS (timer_last_idleness_start_time),
8467 EMACS_USECS (timer_last_idleness_start_time));
8468
8469 /* Resume idle state, using the same start-time as before. */
8470 timer_start_idle ();
8471 timer_idleness_start_time = initial_idleness_start_time;
8472
8473 mock_input = t;
8474 /* Reset the current buffer from the selected window
8475 in case something changed the former and not the latter.
8476 This is to be more consistent with the behavior
8477 of the command_loop_1. */
8478 if (fix_current_buffer)
8479 {
8480 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
8481 Fkill_emacs (Qnil);
8482 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
8483 Fset_buffer (XWINDOW (selected_window)->buffer);
8484 }
8485
8486 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
8487 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
8488 goto replay_sequence;
8489 }
8490
8491 /* If we have a quit that was typed in another frame, and
8492 quit_throw_to_read_char switched buffers,
8493 replay to get the right keymap. */
8494 if (INTEGERP (key)
8495 && XINT (key) == quit_char
8496 && current_buffer != starting_buffer)
8497 {
8498 GROW_RAW_KEYBUF;
8499 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8500 keybuf[t++] = key;
8501 mock_input = t;
8502 Vquit_flag = Qnil;
8503 orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
8504 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
8505 goto replay_sequence;
8506 }
8507
8508 Vquit_flag = Qnil;
8509
8510 if (EVENT_HAS_PARAMETERS (key)
8511 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key)), Qswitch_frame))
8512 {
8513 /* If we're at the beginning of a key sequence, and the caller
8514 says it's okay, go ahead and return this event. If we're
8515 in the midst of a key sequence, delay it until the end. */
8516 if (t > 0 || !can_return_switch_frame)
8517 {
8518 delayed_switch_frame = key;
8519 goto replay_key;
8520 }
8521 }
8522
8523 GROW_RAW_KEYBUF;
8524 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8525 }
8526
8527 /* Clicks in non-text areas get prefixed by the symbol
8528 in their CHAR-ADDRESS field. For example, a click on
8529 the mode line is prefixed by the symbol `mode-line'.
8530
8531 Furthermore, key sequences beginning with mouse clicks
8532 are read using the keymaps of the buffer clicked on, not
8533 the current buffer. So we may have to switch the buffer
8534 here.
8535
8536 When we turn one event into two events, we must make sure
8537 that neither of the two looks like the original--so that,
8538 if we replay the events, they won't be expanded again.
8539 If not for this, such reexpansion could happen either here
8540 or when user programs play with this-command-keys. */
8541 if (EVENT_HAS_PARAMETERS (key))
8542 {
8543 Lisp_Object kind;
8544
8545 kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
8546 if (EQ (kind, Qmouse_click))
8547 {
8548 Lisp_Object window, posn;
8549
8550 window = POSN_WINDOW (EVENT_START (key));
8551 posn = POSN_BUFFER_POSN (EVENT_START (key));
8552
8553 if (CONSP (posn)
8554 || (!NILP (fake_prefixed_keys)
8555 && !NILP (Fmemq (key, fake_prefixed_keys))))
8556 {
8557 /* We're looking a second time at an event for which
8558 we generated a fake prefix key. Set
8559 last_real_key_start appropriately. */
8560 if (t > 0)
8561 last_real_key_start = t - 1;
8562 }
8563
8564 /* Key sequences beginning with mouse clicks are
8565 read using the keymaps in the buffer clicked on,
8566 not the current buffer. If we're at the
8567 beginning of a key sequence, switch buffers. */
8568 if (last_real_key_start == 0
8569 && WINDOWP (window)
8570 && BUFFERP (XWINDOW (window)->buffer)
8571 && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
8572 {
8573 XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
8574 keybuf[t] = key;
8575 mock_input = t + 1;
8576
8577 /* Arrange to go back to the original buffer once we're
8578 done reading the key sequence. Note that we can't
8579 use save_excursion_{save,restore} here, because they
8580 save point as well as the current buffer; we don't
8581 want to save point, because redisplay may change it,
8582 to accommodate a Fset_window_start or something. We
8583 don't want to do this at the top of the function,
8584 because we may get input from a subprocess which
8585 wants to change the selected window and stuff (say,
8586 emacsclient). */
8587 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
8588
8589 if (! FRAME_LIVE_P (XFRAME (selected_frame)))
8590 Fkill_emacs (Qnil);
8591 set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
8592 orig_local_map = get_local_map (PT, current_buffer,
8593 Qlocal_map);
8594 orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
8595 goto replay_sequence;
8596 }
8597
8598 /* For a mouse click, get the local text-property keymap
8599 of the place clicked on, rather than point. */
8600 if (last_real_key_start == 0
8601 && CONSP (XCDR (key))
8602 && ! localized_local_map)
8603 {
8604 Lisp_Object map_here, start, pos;
8605
8606 localized_local_map = 1;
8607 start = EVENT_START (key);
8608
8609 if (CONSP (start) && CONSP (XCDR (start)))
8610 {
8611 pos = POSN_BUFFER_POSN (start);
8612 if (INTEGERP (pos)
8613 && XINT (pos) >= BEG && XINT (pos) <= Z)
8614 {
8615 map_here = get_local_map (XINT (pos),
8616 current_buffer, Qlocal_map);
8617 if (!EQ (map_here, orig_local_map))
8618 {
8619 orig_local_map = map_here;
8620 keybuf[t] = key;
8621 mock_input = t + 1;
8622
8623 goto replay_sequence;
8624 }
8625 map_here = get_local_map (XINT (pos),
8626 current_buffer, Qkeymap);
8627 if (!EQ (map_here, orig_keymap))
8628 {
8629 orig_keymap = map_here;
8630 keybuf[t] = key;
8631 mock_input = t + 1;
8632
8633 goto replay_sequence;
8634 }
8635 }
8636 }
8637 }
8638
8639 /* Expand mode-line and scroll-bar events into two events:
8640 use posn as a fake prefix key. */
8641 if (SYMBOLP (posn)
8642 && (NILP (fake_prefixed_keys)
8643 || NILP (Fmemq (key, fake_prefixed_keys))))
8644 {
8645 if (t + 1 >= bufsize)
8646 error ("Key sequence too long");
8647
8648 keybuf[t] = posn;
8649 keybuf[t + 1] = key;
8650 mock_input = t + 2;
8651
8652 /* Record that a fake prefix key has been generated
8653 for KEY. Don't modify the event; this would
8654 prevent proper action when the event is pushed
8655 back into unread-command-events. */
8656 fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
8657
8658 /* If on a mode line string with a local keymap,
8659 reconsider the key sequence with that keymap. */
8660 if (CONSP (POSN_STRING (EVENT_START (key))))
8661 {
8662 Lisp_Object string, pos, map, map2;
8663
8664 string = POSN_STRING (EVENT_START (key));
8665 pos = XCDR (string);
8666 string = XCAR (string);
8667 if (XINT (pos) >= 0
8668 && XINT (pos) < SCHARS (string))
8669 {
8670 map = Fget_text_property (pos, Qlocal_map, string);
8671 if (!NILP (map))
8672 orig_local_map = map;
8673 map2 = Fget_text_property (pos, Qkeymap, string);
8674 if (!NILP (map2))
8675 orig_keymap = map2;
8676 if (!NILP (map) || !NILP (map2))
8677 goto replay_sequence;
8678 }
8679 }
8680
8681 goto replay_key;
8682 }
8683 else if (CONSP (POSN_STRING (EVENT_START (key)))
8684 && NILP (from_string))
8685 {
8686 /* For a click on a string, i.e. overlay string or a
8687 string displayed via the `display' property,
8688 consider `local-map' and `keymap' properties of
8689 that string. */
8690 Lisp_Object string, pos, map, map2;
8691
8692 string = POSN_STRING (EVENT_START (key));
8693 pos = XCDR (string);
8694 string = XCAR (string);
8695 if (XINT (pos) >= 0
8696 && XINT (pos) < SCHARS (string))
8697 {
8698 map = Fget_text_property (pos, Qlocal_map, string);
8699 if (!NILP (map))
8700 orig_local_map = map;
8701 map2 = Fget_text_property (pos, Qkeymap, string);
8702 if (!NILP (map2))
8703 orig_keymap = map2;
8704
8705 if (!NILP (map) || !NILP (map2))
8706 {
8707 from_string = string;
8708 goto replay_sequence;
8709 }
8710 }
8711 }
8712 }
8713 else if (CONSP (XCDR (key))
8714 && CONSP (EVENT_START (key))
8715 && CONSP (XCDR (EVENT_START (key))))
8716 {
8717 Lisp_Object posn;
8718
8719 posn = POSN_BUFFER_POSN (EVENT_START (key));
8720 /* Handle menu-bar events:
8721 insert the dummy prefix event `menu-bar'. */
8722 if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
8723 {
8724 if (t + 1 >= bufsize)
8725 error ("Key sequence too long");
8726 keybuf[t] = posn;
8727 keybuf[t+1] = key;
8728
8729 /* Zap the position in key, so we know that we've
8730 expanded it, and don't try to do so again. */
8731 POSN_BUFFER_SET_POSN (EVENT_START (key),
8732 Fcons (posn, Qnil));
8733
8734 mock_input = t + 2;
8735 goto replay_sequence;
8736 }
8737 else if (CONSP (posn))
8738 {
8739 /* We're looking at the second event of a
8740 sequence which we expanded before. Set
8741 last_real_key_start appropriately. */
8742 if (last_real_key_start == t && t > 0)
8743 last_real_key_start = t - 1;
8744 }
8745 }
8746 }
8747
8748 /* We have finally decided that KEY is something we might want
8749 to look up. */
8750 first_binding = (follow_key (key,
8751 nmaps - first_binding,
8752 submaps + first_binding,
8753 defs + first_binding,
8754 submaps + first_binding)
8755 + first_binding);
8756
8757 /* If KEY wasn't bound, we'll try some fallbacks. */
8758 if (first_binding < nmaps)
8759 /* This is needed for the following scenario:
8760 event 0: a down-event that gets dropped by calling replay_key.
8761 event 1: some normal prefix like C-h.
8762 After event 0, first_unbound is 0, after event 1 fkey.start
8763 and keytran.start are both 1, so when we see that C-h is bound,
8764 we need to update first_unbound. */
8765 first_unbound = max (t + 1, first_unbound);
8766 else
8767 {
8768 Lisp_Object head;
8769
8770 /* Remember the position to put an upper bound on fkey.start. */
8771 first_unbound = min (t, first_unbound);
8772
8773 head = EVENT_HEAD (key);
8774 if (help_char_p (head) && t > 0)
8775 {
8776 read_key_sequence_cmd = Vprefix_help_command;
8777 keybuf[t++] = key;
8778 last_nonmenu_event = key;
8779 /* The Microsoft C compiler can't handle the goto that
8780 would go here. */
8781 dummyflag = 1;
8782 break;
8783 }
8784
8785 if (SYMBOLP (head))
8786 {
8787 Lisp_Object breakdown;
8788 int modifiers;
8789
8790 breakdown = parse_modifiers (head);
8791 modifiers = XINT (XCAR (XCDR (breakdown)));
8792 /* Attempt to reduce an unbound mouse event to a simpler
8793 event that is bound:
8794 Drags reduce to clicks.
8795 Double-clicks reduce to clicks.
8796 Triple-clicks reduce to double-clicks, then to clicks.
8797 Down-clicks are eliminated.
8798 Double-downs reduce to downs, then are eliminated.
8799 Triple-downs reduce to double-downs, then to downs,
8800 then are eliminated. */
8801 if (modifiers & (down_modifier | drag_modifier
8802 | double_modifier | triple_modifier))
8803 {
8804 while (modifiers & (down_modifier | drag_modifier
8805 | double_modifier | triple_modifier))
8806 {
8807 Lisp_Object new_head, new_click;
8808 if (modifiers & triple_modifier)
8809 modifiers ^= (double_modifier | triple_modifier);
8810 else if (modifiers & double_modifier)
8811 modifiers &= ~double_modifier;
8812 else if (modifiers & drag_modifier)
8813 modifiers &= ~drag_modifier;
8814 else
8815 {
8816 /* Dispose of this `down' event by simply jumping
8817 back to replay_key, to get another event.
8818
8819 Note that if this event came from mock input,
8820 then just jumping back to replay_key will just
8821 hand it to us again. So we have to wipe out any
8822 mock input.
8823
8824 We could delete keybuf[t] and shift everything
8825 after that to the left by one spot, but we'd also
8826 have to fix up any variable that points into
8827 keybuf, and shifting isn't really necessary
8828 anyway.
8829
8830 Adding prefixes for non-textual mouse clicks
8831 creates two characters of mock input, and both
8832 must be thrown away. If we're only looking at
8833 the prefix now, we can just jump back to
8834 replay_key. On the other hand, if we've already
8835 processed the prefix, and now the actual click
8836 itself is giving us trouble, then we've lost the
8837 state of the keymaps we want to backtrack to, and
8838 we need to replay the whole sequence to rebuild
8839 it.
8840
8841 Beyond that, only function key expansion could
8842 create more than two keys, but that should never
8843 generate mouse events, so it's okay to zero
8844 mock_input in that case too.
8845
8846 FIXME: The above paragraph seems just plain
8847 wrong, if you consider things like
8848 xterm-mouse-mode. -stef
8849
8850 Isn't this just the most wonderful code ever? */
8851 if (t == last_real_key_start)
8852 {
8853 mock_input = 0;
8854 goto replay_key;
8855 }
8856 else
8857 {
8858 mock_input = last_real_key_start;
8859 goto replay_sequence;
8860 }
8861 }
8862
8863 new_head
8864 = apply_modifiers (modifiers, XCAR (breakdown));
8865 new_click
8866 = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
8867
8868 /* Look for a binding for this new key. follow_key
8869 promises that it didn't munge submaps the
8870 last time we called it, since key was unbound. */
8871 first_binding
8872 = (follow_key (new_click,
8873 nmaps - local_first_binding,
8874 submaps + local_first_binding,
8875 defs + local_first_binding,
8876 submaps + local_first_binding)
8877 + local_first_binding);
8878
8879 /* If that click is bound, go for it. */
8880 if (first_binding < nmaps)
8881 {
8882 key = new_click;
8883 break;
8884 }
8885 /* Otherwise, we'll leave key set to the drag event. */
8886 }
8887 }
8888 }
8889 }
8890
8891 keybuf[t++] = key;
8892 /* Normally, last_nonmenu_event gets the previous key we read.
8893 But when a mouse popup menu is being used,
8894 we don't update last_nonmenu_event; it continues to hold the mouse
8895 event that preceded the first level of menu. */
8896 if (!used_mouse_menu)
8897 last_nonmenu_event = key;
8898
8899 /* Record what part of this_command_keys is the current key sequence. */
8900 this_single_command_key_start = this_command_key_count - t;
8901
8902 if (first_binding < nmaps && NILP (submaps[first_binding]))
8903 /* There is a binding and it's not a prefix.
8904 There is thus no function-key in this sequence.
8905 Moving fkey.start is important in this case to allow keytran.start
8906 to go over the sequence before we return (since we keep the
8907 invariant that keytran.end <= fkey.start). */
8908 {
8909 if (fkey.start < t)
8910 (fkey.start = fkey.end = t, fkey.map = Vfunction_key_map);
8911 }
8912 else
8913 /* If the sequence is unbound, see if we can hang a function key
8914 off the end of it. */
8915 {
8916 Lisp_Object next;
8917
8918 /* Continue scan from fkey.end until we find a bound suffix.
8919 If we fail, increment fkey.start and start over from there. */
8920 while (fkey.end < t)
8921 {
8922 Lisp_Object key;
8923
8924 key = keybuf[fkey.end++];
8925 next = access_keymap (fkey.map, key, 1, 0, 1);
8926
8927 /* Handle symbol with autoload definition. */
8928 if (SYMBOLP (next) && ! NILP (Ffboundp (next))
8929 && CONSP (XSYMBOL (next)->function)
8930 && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
8931 do_autoload (XSYMBOL (next)->function, next);
8932
8933 /* Handle a symbol whose function definition is a keymap
8934 or an array. */
8935 if (SYMBOLP (next) && ! NILP (Ffboundp (next))
8936 && (!NILP (Farrayp (XSYMBOL (next)->function))
8937 || KEYMAPP (XSYMBOL (next)->function)))
8938 next = XSYMBOL (next)->function;
8939
8940 #if 0 /* I didn't turn this on, because it might cause trouble
8941 for the mapping of return into C-m and tab into C-i. */
8942 /* Optionally don't map function keys into other things.
8943 This enables the user to redefine kp- keys easily. */
8944 if (SYMBOLP (key) && !NILP (Vinhibit_function_key_mapping))
8945 next = Qnil;
8946 #endif
8947
8948 /* If the function key map gives a function, not an
8949 array, then call the function with no args and use
8950 its value instead. */
8951 if (SYMBOLP (next) && ! NILP (Ffboundp (next))
8952 /* If there's a binding (i.e. first_binding >= nmaps)
8953 we don't want to apply this function-key-mapping. */
8954 && fkey.end == t && first_binding >= nmaps)
8955 {
8956 struct gcpro gcpro1, gcpro2, gcpro3;
8957 Lisp_Object tem;
8958 tem = next;
8959
8960 GCPRO3 (fkey.map, keytran.map, delayed_switch_frame);
8961 next = call1 (next, prompt);
8962 UNGCPRO;
8963 /* If the function returned something invalid,
8964 barf--don't ignore it.
8965 (To ignore it safely, we would need to gcpro a bunch of
8966 other variables.) */
8967 if (! (VECTORP (next) || STRINGP (next)))
8968 error ("Function in key-translation-map returns invalid key sequence");
8969 }
8970
8971 /* If keybuf[fkey.start..fkey.end] is bound in the
8972 function key map and it's a suffix of the current
8973 sequence (i.e. fkey.end == t), replace it with
8974 the binding and restart with fkey.start at the end. */
8975 if ((VECTORP (next) || STRINGP (next))
8976 /* If there's a binding (i.e. first_binding >= nmaps)
8977 we don't want to apply this function-key-mapping. */
8978 && fkey.end == t && first_binding >= nmaps)
8979 {
8980 int len = XFASTINT (Flength (next));
8981
8982 t = fkey.start + len;
8983 if (t >= bufsize)
8984 error ("Key sequence too long");
8985
8986 if (VECTORP (next))
8987 bcopy (XVECTOR (next)->contents,
8988 keybuf + fkey.start,
8989 (t - fkey.start) * sizeof (keybuf[0]));
8990 else if (STRINGP (next))
8991 {
8992 int i;
8993
8994 for (i = 0; i < len; i++)
8995 XSETFASTINT (keybuf[fkey.start + i], SREF (next, i));
8996 }
8997
8998 mock_input = t;
8999 fkey.start = fkey.end = t;
9000 fkey.map = Vfunction_key_map;
9001
9002 /* Do pass the results through key-translation-map.
9003 But don't retranslate what key-translation-map
9004 has already translated. */
9005 keytran.end = keytran.start;
9006 keytran.map = Vkey_translation_map;
9007
9008 goto replay_sequence;
9009 }
9010
9011 fkey.map = get_keymap (next, 0, 1);
9012
9013 /* If we no longer have a bound suffix, try a new positions for
9014 fkey.start. */
9015 if (!CONSP (fkey.map))
9016 {
9017 fkey.end = ++fkey.start;
9018 fkey.map = Vfunction_key_map;
9019 }
9020 }
9021 }
9022
9023 /* Look for this sequence in key-translation-map. */
9024 {
9025 Lisp_Object next;
9026
9027 /* Scan from keytran.end until we find a bound suffix. */
9028 while (keytran.end < fkey.start)
9029 {
9030 Lisp_Object key;
9031
9032 key = keybuf[keytran.end++];
9033 next = access_keymap (keytran.map, key, 1, 0, 1);
9034
9035 /* Handle symbol with autoload definition. */
9036 if (SYMBOLP (next) && ! NILP (Ffboundp (next))
9037 && CONSP (XSYMBOL (next)->function)
9038 && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
9039 do_autoload (XSYMBOL (next)->function, next);
9040
9041 /* Handle a symbol whose function definition is a keymap
9042 or an array. */
9043 if (SYMBOLP (next) && ! NILP (Ffboundp (next))
9044 && (!NILP (Farrayp (XSYMBOL (next)->function))
9045 || KEYMAPP (XSYMBOL (next)->function)))
9046 next = XSYMBOL (next)->function;
9047
9048 /* If the key translation map gives a function, not an
9049 array, then call the function with one arg and use
9050 its value instead. */
9051 if (SYMBOLP (next) && ! NILP (Ffboundp (next)))
9052 {
9053 struct gcpro gcpro1, gcpro2, gcpro3;
9054 Lisp_Object tem;
9055 tem = next;
9056
9057 GCPRO3 (fkey.map, keytran.map, delayed_switch_frame);
9058 next = call1 (next, prompt);
9059 UNGCPRO;
9060 /* If the function returned something invalid,
9061 barf--don't ignore it.
9062 (To ignore it safely, we would need to gcpro a bunch of
9063 other variables.) */
9064 if (! (VECTORP (next) || STRINGP (next)))
9065 error ("Function in key-translation-map returns invalid key sequence");
9066 }
9067
9068 /* If keybuf[keytran.start..keytran.end] is bound in the
9069 key translation map and it's a suffix of the current
9070 sequence (i.e. keytran.end == t), replace it with
9071 the binding and restart with keytran.start at the end. */
9072 if ((VECTORP (next) || STRINGP (next)))
9073 {
9074 int len = XFASTINT (Flength (next));
9075 int i, diff = len - (keytran.end - keytran.start);
9076
9077 mock_input = max (t, mock_input);
9078 if (mock_input + diff >= bufsize)
9079 error ("Key sequence too long");
9080
9081 /* Shift the keys that are after keytran.end. */
9082 if (diff < 0)
9083 for (i = keytran.end; i < mock_input; i++)
9084 keybuf[i + diff] = keybuf[i];
9085 else if (diff > 0)
9086 for (i = mock_input - 1; i >= keytran.end; i--)
9087 keybuf[i + diff] = keybuf[i];
9088 /* Replace the keys between keytran.start and keytran.end
9089 with those from next. */
9090 for (i = 0; i < len; i++)
9091 keybuf[keytran.start + i]
9092 = Faref (next, make_number (i));
9093
9094 mock_input += diff;
9095 keytran.start = keytran.end += diff;
9096 keytran.map = Vkey_translation_map;
9097
9098 /* Adjust the function-key-map counters. */
9099 fkey.start += diff;
9100 fkey.end += diff;
9101
9102 goto replay_sequence;
9103 }
9104
9105 keytran.map = get_keymap (next, 0, 1);
9106
9107 /* If we no longer have a bound suffix, try a new positions for
9108 keytran.start. */
9109 if (!CONSP (keytran.map))
9110 {
9111 keytran.end = ++keytran.start;
9112 keytran.map = Vkey_translation_map;
9113 }
9114 }
9115 }
9116
9117 /* If KEY is not defined in any of the keymaps,
9118 and cannot be part of a function key or translation,
9119 and is an upper case letter
9120 use the corresponding lower-case letter instead. */
9121 if (first_binding >= nmaps
9122 && fkey.start >= t && keytran.start >= t
9123 && INTEGERP (key)
9124 && ((((XINT (key) & 0x3ffff)
9125 < XCHAR_TABLE (current_buffer->downcase_table)->size)
9126 && UPPERCASEP (XINT (key) & 0x3ffff))
9127 || (XINT (key) & shift_modifier)))
9128 {
9129 Lisp_Object new_key;
9130
9131 original_uppercase = key;
9132 original_uppercase_position = t - 1;
9133
9134 if (XINT (key) & shift_modifier)
9135 XSETINT (new_key, XINT (key) & ~shift_modifier);
9136 else
9137 XSETINT (new_key, (DOWNCASE (XINT (key) & 0x3ffff)
9138 | (XINT (key) & ~0x3ffff)));
9139
9140 /* We have to do this unconditionally, regardless of whether
9141 the lower-case char is defined in the keymaps, because they
9142 might get translated through function-key-map. */
9143 keybuf[t - 1] = new_key;
9144 mock_input = max (t, mock_input);
9145
9146 goto replay_sequence;
9147 }
9148 /* If KEY is not defined in any of the keymaps,
9149 and cannot be part of a function key or translation,
9150 and is a shifted function key,
9151 use the corresponding unshifted function key instead. */
9152 if (first_binding >= nmaps
9153 && fkey.start >= t && keytran.start >= t
9154 && SYMBOLP (key))
9155 {
9156 Lisp_Object breakdown;
9157 int modifiers;
9158
9159 breakdown = parse_modifiers (key);
9160 modifiers = XINT (XCAR (XCDR (breakdown)));
9161 if (modifiers & shift_modifier)
9162 {
9163 Lisp_Object new_key;
9164
9165 original_uppercase = key;
9166 original_uppercase_position = t - 1;
9167
9168 modifiers &= ~shift_modifier;
9169 new_key = apply_modifiers (modifiers,
9170 XCAR (breakdown));
9171
9172 keybuf[t - 1] = new_key;
9173 mock_input = max (t, mock_input);
9174
9175 goto replay_sequence;
9176 }
9177 }
9178 }
9179
9180 if (!dummyflag)
9181 read_key_sequence_cmd = (first_binding < nmaps
9182 ? defs[first_binding]
9183 : Qnil);
9184
9185 unread_switch_frame = delayed_switch_frame;
9186 unbind_to (count, Qnil);
9187
9188 /* Don't downcase the last character if the caller says don't.
9189 Don't downcase it if the result is undefined, either. */
9190 if ((dont_downcase_last || first_binding >= nmaps)
9191 && t - 1 == original_uppercase_position)
9192 keybuf[t - 1] = original_uppercase;
9193
9194 /* Occasionally we fabricate events, perhaps by expanding something
9195 according to function-key-map, or by adding a prefix symbol to a
9196 mouse click in the scroll bar or modeline. In this cases, return
9197 the entire generated key sequence, even if we hit an unbound
9198 prefix or a definition before the end. This means that you will
9199 be able to push back the event properly, and also means that
9200 read-key-sequence will always return a logical unit.
9201
9202 Better ideas? */
9203 for (; t < mock_input; t++)
9204 {
9205 if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
9206 && NILP (Fzerop (Vecho_keystrokes)))
9207 echo_char (keybuf[t]);
9208 add_command_key (keybuf[t]);
9209 }
9210
9211
9212
9213 UNGCPRO;
9214 return t;
9215 }
9216
9217 DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 5, 0,
9218 doc: /* Read a sequence of keystrokes and return as a string or vector.
9219 The sequence is sufficient to specify a non-prefix command in the
9220 current local and global maps.
9221
9222 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9223 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9224 as a continuation of the previous key.
9225
9226 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9227 convert the last event to lower case. (Normally any upper case event
9228 is converted to lower case if the original event is undefined and the lower
9229 case equivalent is defined.) A non-nil value is appropriate for reading
9230 a key sequence to be defined.
9231
9232 A C-g typed while in this function is treated like any other character,
9233 and `quit-flag' is not set.
9234
9235 If the key sequence starts with a mouse click, then the sequence is read
9236 using the keymaps of the buffer of the window clicked in, not the buffer
9237 of the selected window as normal.
9238
9239 `read-key-sequence' drops unbound button-down events, since you normally
9240 only care about the click or drag events which follow them. If a drag
9241 or multi-click event is unbound, but the corresponding click event would
9242 be bound, `read-key-sequence' turns the event into a click event at the
9243 drag's starting position. This means that you don't have to distinguish
9244 between click and drag, double, or triple events unless you want to.
9245
9246 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9247 lines separating windows, and scroll bars with imaginary keys
9248 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9249
9250 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9251 function will process a switch-frame event if the user switches frames
9252 before typing anything. If the user switches frames in the middle of a
9253 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9254 is nil, then the event will be put off until after the current key sequence.
9255
9256 `read-key-sequence' checks `function-key-map' for function key
9257 sequences, where they wouldn't conflict with ordinary bindings. See
9258 `function-key-map' for more details.
9259
9260 The optional fifth argument COMMAND-LOOP, if non-nil, means
9261 that this key sequence is being read by something that will
9262 read commands one after another. It should be nil if the caller
9263 will read just one key sequence. */)
9264 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
9265 command_loop)
9266 Lisp_Object prompt, continue_echo, dont_downcase_last;
9267 Lisp_Object can_return_switch_frame, command_loop;
9268 {
9269 Lisp_Object keybuf[30];
9270 register int i;
9271 struct gcpro gcpro1;
9272 int count = SPECPDL_INDEX ();
9273
9274 if (!NILP (prompt))
9275 CHECK_STRING (prompt);
9276 QUIT;
9277
9278 specbind (Qinput_method_exit_on_first_char,
9279 (NILP (command_loop) ? Qt : Qnil));
9280 specbind (Qinput_method_use_echo_area,
9281 (NILP (command_loop) ? Qt : Qnil));
9282
9283 bzero (keybuf, sizeof keybuf);
9284 GCPRO1 (keybuf[0]);
9285 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
9286
9287 if (NILP (continue_echo))
9288 {
9289 this_command_key_count = 0;
9290 this_single_command_key_start = 0;
9291 }
9292
9293 #ifdef HAVE_X_WINDOWS
9294 if (display_hourglass_p)
9295 cancel_hourglass ();
9296 #endif
9297
9298 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
9299 prompt, ! NILP (dont_downcase_last),
9300 ! NILP (can_return_switch_frame), 0);
9301
9302 #if 0 /* The following is fine for code reading a key sequence and
9303 then proceeding with a lenghty computation, but it's not good
9304 for code reading keys in a loop, like an input method. */
9305 #ifdef HAVE_X_WINDOWS
9306 if (display_hourglass_p)
9307 start_hourglass ();
9308 #endif
9309 #endif
9310
9311 if (i == -1)
9312 {
9313 Vquit_flag = Qt;
9314 QUIT;
9315 }
9316 UNGCPRO;
9317 return unbind_to (count, make_event_array (i, keybuf));
9318 }
9319
9320 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
9321 Sread_key_sequence_vector, 1, 5, 0,
9322 doc: /* Like `read-key-sequence' but always return a vector. */)
9323 (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
9324 command_loop)
9325 Lisp_Object prompt, continue_echo, dont_downcase_last;
9326 Lisp_Object can_return_switch_frame, command_loop;
9327 {
9328 Lisp_Object keybuf[30];
9329 register int i;
9330 struct gcpro gcpro1;
9331 int count = SPECPDL_INDEX ();
9332
9333 if (!NILP (prompt))
9334 CHECK_STRING (prompt);
9335 QUIT;
9336
9337 specbind (Qinput_method_exit_on_first_char,
9338 (NILP (command_loop) ? Qt : Qnil));
9339 specbind (Qinput_method_use_echo_area,
9340 (NILP (command_loop) ? Qt : Qnil));
9341
9342 bzero (keybuf, sizeof keybuf);
9343 GCPRO1 (keybuf[0]);
9344 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
9345
9346 if (NILP (continue_echo))
9347 {
9348 this_command_key_count = 0;
9349 this_single_command_key_start = 0;
9350 }
9351
9352 #ifdef HAVE_X_WINDOWS
9353 if (display_hourglass_p)
9354 cancel_hourglass ();
9355 #endif
9356
9357 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
9358 prompt, ! NILP (dont_downcase_last),
9359 ! NILP (can_return_switch_frame), 0);
9360
9361 #ifdef HAVE_X_WINDOWS
9362 if (display_hourglass_p)
9363 start_hourglass ();
9364 #endif
9365
9366 if (i == -1)
9367 {
9368 Vquit_flag = Qt;
9369 QUIT;
9370 }
9371 UNGCPRO;
9372 return unbind_to (count, Fvector (i, keybuf));
9373 }
9374 \f
9375 DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
9376 doc: /* Execute CMD as an editor command.
9377 CMD must be a symbol that satisfies the `commandp' predicate.
9378 Optional second arg RECORD-FLAG non-nil
9379 means unconditionally put this command in `command-history'.
9380 Otherwise, that is done only if an arg is read using the minibuffer.
9381 The argument KEYS specifies the value to use instead of (this-command-keys)
9382 when reading the arguments; if it is nil, (this-command-keys) is used.
9383 The argument SPECIAL, if non-nil, means that this command is executing
9384 a special event, so ignore the prefix argument and don't clear it. */)
9385 (cmd, record_flag, keys, special)
9386 Lisp_Object cmd, record_flag, keys, special;
9387 {
9388 register Lisp_Object final;
9389 register Lisp_Object tem;
9390 Lisp_Object prefixarg;
9391 struct backtrace backtrace;
9392 extern int debug_on_next_call;
9393
9394 debug_on_next_call = 0;
9395
9396 if (NILP (special))
9397 {
9398 prefixarg = current_kboard->Vprefix_arg;
9399 Vcurrent_prefix_arg = prefixarg;
9400 current_kboard->Vprefix_arg = Qnil;
9401 }
9402 else
9403 prefixarg = Qnil;
9404
9405 if (SYMBOLP (cmd))
9406 {
9407 tem = Fget (cmd, Qdisabled);
9408 if (!NILP (tem) && !NILP (Vrun_hooks))
9409 {
9410 tem = Fsymbol_value (Qdisabled_command_hook);
9411 if (!NILP (tem))
9412 return call1 (Vrun_hooks, Qdisabled_command_hook);
9413 }
9414 }
9415
9416 while (1)
9417 {
9418 final = Findirect_function (cmd);
9419
9420 if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
9421 {
9422 struct gcpro gcpro1, gcpro2;
9423
9424 GCPRO2 (cmd, prefixarg);
9425 do_autoload (final, cmd);
9426 UNGCPRO;
9427 }
9428 else
9429 break;
9430 }
9431
9432 if (STRINGP (final) || VECTORP (final))
9433 {
9434 /* If requested, place the macro in the command history. For
9435 other sorts of commands, call-interactively takes care of
9436 this. */
9437 if (!NILP (record_flag))
9438 {
9439 Vcommand_history
9440 = Fcons (Fcons (Qexecute_kbd_macro,
9441 Fcons (final, Fcons (prefixarg, Qnil))),
9442 Vcommand_history);
9443
9444 /* Don't keep command history around forever. */
9445 if (NUMBERP (Vhistory_length) && XINT (Vhistory_length) > 0)
9446 {
9447 tem = Fnthcdr (Vhistory_length, Vcommand_history);
9448 if (CONSP (tem))
9449 XSETCDR (tem, Qnil);
9450 }
9451 }
9452
9453 return Fexecute_kbd_macro (final, prefixarg, Qnil);
9454 }
9455
9456 if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
9457 {
9458 backtrace.next = backtrace_list;
9459 backtrace_list = &backtrace;
9460 backtrace.function = &Qcall_interactively;
9461 backtrace.args = &cmd;
9462 backtrace.nargs = 1;
9463 backtrace.evalargs = 0;
9464
9465 tem = Fcall_interactively (cmd, record_flag, keys);
9466
9467 backtrace_list = backtrace.next;
9468 return tem;
9469 }
9470 return Qnil;
9471 }
9472
9473
9474 \f
9475 DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
9476 1, 1, "P",
9477 doc: /* Read function name, then read its arguments and call it. */)
9478 (prefixarg)
9479 Lisp_Object prefixarg;
9480 {
9481 Lisp_Object function;
9482 char buf[40];
9483 int saved_last_point_position;
9484 Lisp_Object saved_keys, saved_last_point_position_buffer;
9485 Lisp_Object bindings, value;
9486 struct gcpro gcpro1, gcpro2, gcpro3;
9487
9488 saved_keys = Fvector (this_command_key_count,
9489 XVECTOR (this_command_keys)->contents);
9490 saved_last_point_position_buffer = last_point_position_buffer;
9491 saved_last_point_position = last_point_position;
9492 buf[0] = 0;
9493 GCPRO3 (saved_keys, prefixarg, saved_last_point_position_buffer);
9494
9495 if (EQ (prefixarg, Qminus))
9496 strcpy (buf, "- ");
9497 else if (CONSP (prefixarg) && XINT (XCAR (prefixarg)) == 4)
9498 strcpy (buf, "C-u ");
9499 else if (CONSP (prefixarg) && INTEGERP (XCAR (prefixarg)))
9500 {
9501 if (sizeof (int) == sizeof (EMACS_INT))
9502 sprintf (buf, "%d ", XINT (XCAR (prefixarg)));
9503 else if (sizeof (long) == sizeof (EMACS_INT))
9504 sprintf (buf, "%ld ", (long) XINT (XCAR (prefixarg)));
9505 else
9506 abort ();
9507 }
9508 else if (INTEGERP (prefixarg))
9509 {
9510 if (sizeof (int) == sizeof (EMACS_INT))
9511 sprintf (buf, "%d ", XINT (prefixarg));
9512 else if (sizeof (long) == sizeof (EMACS_INT))
9513 sprintf (buf, "%ld ", (long) XINT (prefixarg));
9514 else
9515 abort ();
9516 }
9517
9518 /* This isn't strictly correct if execute-extended-command
9519 is bound to anything else. Perhaps it should use
9520 this_command_keys? */
9521 strcat (buf, "M-x ");
9522
9523 /* Prompt with buf, and then read a string, completing from and
9524 restricting to the set of all defined commands. Don't provide
9525 any initial input. Save the command read on the extended-command
9526 history list. */
9527 function = Fcompleting_read (build_string (buf),
9528 Vobarray, Qcommandp,
9529 Qt, Qnil, Qextended_command_history, Qnil,
9530 Qnil);
9531
9532 if (STRINGP (function) && SCHARS (function) == 0)
9533 error ("No command name given");
9534
9535 /* Set this_command_keys to the concatenation of saved_keys and
9536 function, followed by a RET. */
9537 {
9538 Lisp_Object *keys;
9539 int i;
9540
9541 this_command_key_count = 0;
9542 this_single_command_key_start = 0;
9543
9544 keys = XVECTOR (saved_keys)->contents;
9545 for (i = 0; i < XVECTOR (saved_keys)->size; i++)
9546 add_command_key (keys[i]);
9547
9548 for (i = 0; i < SCHARS (function); i++)
9549 add_command_key (Faref (function, make_number (i)));
9550
9551 add_command_key (make_number ('\015'));
9552 }
9553
9554 last_point_position = saved_last_point_position;
9555 last_point_position_buffer = saved_last_point_position_buffer;
9556
9557 UNGCPRO;
9558
9559 function = Fintern (function, Qnil);
9560 current_kboard->Vprefix_arg = prefixarg;
9561 Vthis_command = function;
9562 real_this_command = function;
9563
9564 /* If enabled, show which key runs this command. */
9565 if (!NILP (Vsuggest_key_bindings)
9566 && NILP (Vexecuting_macro)
9567 && SYMBOLP (function))
9568 bindings = Fwhere_is_internal (function, Voverriding_local_map,
9569 Qt, Qnil, Qnil);
9570 else
9571 bindings = Qnil;
9572
9573 value = Qnil;
9574 GCPRO2 (bindings, value);
9575 value = Fcommand_execute (function, Qt, Qnil, Qnil);
9576
9577 /* If the command has a key binding, print it now. */
9578 if (!NILP (bindings)
9579 && ! (VECTORP (bindings) && EQ (Faref (bindings, make_number (0)),
9580 Qmouse_movement)))
9581 {
9582 /* But first wait, and skip the message if there is input. */
9583 int delay_time;
9584 if (!NILP (echo_area_buffer[0]))
9585 /* This command displayed something in the echo area;
9586 so wait a few seconds, then display our suggestion message. */
9587 delay_time = (NUMBERP (Vsuggest_key_bindings)
9588 ? XINT (Vsuggest_key_bindings) : 2);
9589 else
9590 /* This command left the echo area empty,
9591 so display our message immediately. */
9592 delay_time = 0;
9593
9594 if (!NILP (Fsit_for (make_number (delay_time), Qnil, Qnil))
9595 && ! CONSP (Vunread_command_events))
9596 {
9597 Lisp_Object binding;
9598 char *newmessage;
9599 int message_p = push_message ();
9600 int count = SPECPDL_INDEX ();
9601
9602 record_unwind_protect (pop_message_unwind, Qnil);
9603 binding = Fkey_description (bindings);
9604
9605 newmessage
9606 = (char *) alloca (SCHARS (SYMBOL_NAME (function))
9607 + SBYTES (binding)
9608 + 100);
9609 sprintf (newmessage, "You can run the command `%s' with %s",
9610 SDATA (SYMBOL_NAME (function)),
9611 SDATA (binding));
9612 message2_nolog (newmessage,
9613 strlen (newmessage),
9614 STRING_MULTIBYTE (binding));
9615 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings)
9616 ? Vsuggest_key_bindings : make_number (2)),
9617 Qnil, Qnil))
9618 && message_p)
9619 restore_message ();
9620
9621 unbind_to (count, Qnil);
9622 }
9623 }
9624
9625 RETURN_UNGCPRO (value);
9626 }
9627
9628 \f
9629 /* Return nonzero if input events are pending. */
9630
9631 int
9632 detect_input_pending ()
9633 {
9634 if (!input_pending)
9635 get_input_pending (&input_pending, 0);
9636
9637 return input_pending;
9638 }
9639
9640 /* Return nonzero if input events are pending, and run any pending timers. */
9641
9642 int
9643 detect_input_pending_run_timers (do_display)
9644 int do_display;
9645 {
9646 int old_timers_run = timers_run;
9647
9648 if (!input_pending)
9649 get_input_pending (&input_pending, 1);
9650
9651 if (old_timers_run != timers_run && do_display)
9652 {
9653 redisplay_preserve_echo_area (8);
9654 /* The following fixes a bug when using lazy-lock with
9655 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9656 from an idle timer function. The symptom of the bug is that
9657 the cursor sometimes doesn't become visible until the next X
9658 event is processed. --gerd. */
9659 if (rif)
9660 rif->flush_display (NULL);
9661 }
9662
9663 return input_pending;
9664 }
9665
9666 /* This is called in some cases before a possible quit.
9667 It cases the next call to detect_input_pending to recompute input_pending.
9668 So calling this function unnecessarily can't do any harm. */
9669
9670 void
9671 clear_input_pending ()
9672 {
9673 input_pending = 0;
9674 }
9675
9676 /* Return nonzero if there are pending requeued events.
9677 This isn't used yet. The hope is to make wait_reading_process_input
9678 call it, and return if it runs Lisp code that unreads something.
9679 The problem is, kbd_buffer_get_event needs to be fixed to know what
9680 to do in that case. It isn't trivial. */
9681
9682 int
9683 requeued_events_pending_p ()
9684 {
9685 return (!NILP (Vunread_command_events) || unread_command_char != -1);
9686 }
9687
9688
9689 DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
9690 doc: /* Return t if command input is currently available with no wait.
9691 Actually, the value is nil only if we can be sure that no input is available;
9692 if there is a doubt, the value is t. */)
9693 ()
9694 {
9695 if (!NILP (Vunread_command_events) || unread_command_char != -1)
9696 return (Qt);
9697
9698 get_filtered_input_pending (&input_pending, 1, 1);
9699 return input_pending > 0 ? Qt : Qnil;
9700 }
9701
9702 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
9703 doc: /* Return vector of last 100 events, not counting those from keyboard macros. */)
9704 ()
9705 {
9706 Lisp_Object *keys = XVECTOR (recent_keys)->contents;
9707 Lisp_Object val;
9708
9709 if (total_keys < NUM_RECENT_KEYS)
9710 return Fvector (total_keys, keys);
9711 else
9712 {
9713 val = Fvector (NUM_RECENT_KEYS, keys);
9714 bcopy (keys + recent_keys_index,
9715 XVECTOR (val)->contents,
9716 (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
9717 bcopy (keys,
9718 XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
9719 recent_keys_index * sizeof (Lisp_Object));
9720 return val;
9721 }
9722 }
9723
9724 DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
9725 doc: /* Return the key sequence that invoked this command.
9726 However, if the command has called `read-key-sequence', it returns
9727 the last key sequence that has been read.
9728 The value is a string or a vector. */)
9729 ()
9730 {
9731 return make_event_array (this_command_key_count,
9732 XVECTOR (this_command_keys)->contents);
9733 }
9734
9735 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
9736 doc: /* Return the key sequence that invoked this command, as a vector.
9737 However, if the command has called `read-key-sequence', it returns
9738 the last key sequence that has been read. */)
9739 ()
9740 {
9741 return Fvector (this_command_key_count,
9742 XVECTOR (this_command_keys)->contents);
9743 }
9744
9745 DEFUN ("this-single-command-keys", Fthis_single_command_keys,
9746 Sthis_single_command_keys, 0, 0, 0,
9747 doc: /* Return the key sequence that invoked this command.
9748 More generally, it returns the last key sequence read, either by
9749 the command loop or by `read-key-sequence'.
9750 Unlike `this-command-keys', this function's value
9751 does not include prefix arguments.
9752 The value is always a vector. */)
9753 ()
9754 {
9755 return Fvector (this_command_key_count
9756 - this_single_command_key_start,
9757 (XVECTOR (this_command_keys)->contents
9758 + this_single_command_key_start));
9759 }
9760
9761 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys,
9762 Sthis_single_command_raw_keys, 0, 0, 0,
9763 doc: /* Return the raw events that were read for this command.
9764 More generally, it returns the last key sequence read, either by
9765 the command loop or by `read-key-sequence'.
9766 Unlike `this-single-command-keys', this function's value
9767 shows the events before all translations (except for input methods).
9768 The value is always a vector. */)
9769 ()
9770 {
9771 return Fvector (raw_keybuf_count,
9772 (XVECTOR (raw_keybuf)->contents));
9773 }
9774
9775 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
9776 Sreset_this_command_lengths, 0, 0, 0,
9777 doc: /* Used for complicated reasons in `universal-argument-other-key'.
9778
9779 `universal-argument-other-key' rereads the event just typed.
9780 It then gets translated through `function-key-map'.
9781 The translated event gets included in the echo area and in
9782 the value of `this-command-keys' in addition to the raw original event.
9783 That is not right.
9784
9785 Calling this function directs the translated event to replace
9786 the original event, so that only one version of the event actually
9787 appears in the echo area and in the value of `this-command-keys'. */)
9788 ()
9789 {
9790 before_command_restore_flag = 1;
9791 before_command_key_count_1 = before_command_key_count;
9792 before_command_echo_length_1 = before_command_echo_length;
9793 return Qnil;
9794 }
9795
9796 DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
9797 Sclear_this_command_keys, 0, 1, 0,
9798 doc: /* Clear out the vector that `this-command-keys' returns.
9799 Also clear the record of the last 100 events, unless optional arg
9800 KEEP-RECORD is non-nil. */)
9801 (keep_record)
9802 Lisp_Object keep_record;
9803 {
9804 int i;
9805
9806 this_command_key_count = 0;
9807
9808 if (NILP (keep_record))
9809 {
9810 for (i = 0; i < XVECTOR (recent_keys)->size; ++i)
9811 XVECTOR (recent_keys)->contents[i] = Qnil;
9812 total_keys = 0;
9813 recent_keys_index = 0;
9814 }
9815 return Qnil;
9816 }
9817
9818 DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
9819 doc: /* Return the current depth in recursive edits. */)
9820 ()
9821 {
9822 Lisp_Object temp;
9823 XSETFASTINT (temp, command_loop_level + minibuf_level);
9824 return temp;
9825 }
9826
9827 DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
9828 "FOpen dribble file: ",
9829 doc: /* Start writing all keyboard characters to a dribble file called FILE.
9830 If FILE is nil, close any open dribble file. */)
9831 (file)
9832 Lisp_Object file;
9833 {
9834 if (dribble)
9835 {
9836 fclose (dribble);
9837 dribble = 0;
9838 }
9839 if (!NILP (file))
9840 {
9841 file = Fexpand_file_name (file, Qnil);
9842 dribble = fopen (SDATA (file), "w");
9843 if (dribble == 0)
9844 report_file_error ("Opening dribble", Fcons (file, Qnil));
9845 }
9846 return Qnil;
9847 }
9848
9849 DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
9850 doc: /* Discard the contents of the terminal input buffer.
9851 Also end any kbd macro being defined. */)
9852 ()
9853 {
9854 if (!NILP (current_kboard->defining_kbd_macro))
9855 {
9856 /* Discard the last command from the macro. */
9857 Fcancel_kbd_macro_events ();
9858 end_kbd_macro ();
9859 }
9860
9861 update_mode_lines++;
9862
9863 Vunread_command_events = Qnil;
9864 unread_command_char = -1;
9865
9866 discard_tty_input ();
9867
9868 kbd_fetch_ptr = kbd_store_ptr;
9869 Ffillarray (kbd_buffer_gcpro, Qnil);
9870 input_pending = 0;
9871
9872 return Qnil;
9873 }
9874 \f
9875 DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
9876 doc: /* Stop Emacs and return to superior process. You can resume later.
9877 If `cannot-suspend' is non-nil, or if the system doesn't support job
9878 control, run a subshell instead.
9879
9880 If optional arg STUFFSTRING is non-nil, its characters are stuffed
9881 to be read as terminal input by Emacs's parent, after suspension.
9882
9883 Before suspending, run the normal hook `suspend-hook'.
9884 After resumption run the normal hook `suspend-resume-hook'.
9885
9886 Some operating systems cannot stop the Emacs process and resume it later.
9887 On such systems, Emacs starts a subshell instead of suspending. */)
9888 (stuffstring)
9889 Lisp_Object stuffstring;
9890 {
9891 int count = SPECPDL_INDEX ();
9892 int old_height, old_width;
9893 int width, height;
9894 struct gcpro gcpro1;
9895
9896 if (!NILP (stuffstring))
9897 CHECK_STRING (stuffstring);
9898
9899 /* Run the functions in suspend-hook. */
9900 if (!NILP (Vrun_hooks))
9901 call1 (Vrun_hooks, intern ("suspend-hook"));
9902
9903 GCPRO1 (stuffstring);
9904 get_frame_size (&old_width, &old_height);
9905 reset_sys_modes ();
9906 /* sys_suspend can get an error if it tries to fork a subshell
9907 and the system resources aren't available for that. */
9908 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_sys_modes,
9909 Qnil);
9910 stuff_buffered_input (stuffstring);
9911 if (cannot_suspend)
9912 sys_subshell ();
9913 else
9914 sys_suspend ();
9915 unbind_to (count, Qnil);
9916
9917 /* Check if terminal/window size has changed.
9918 Note that this is not useful when we are running directly
9919 with a window system; but suspend should be disabled in that case. */
9920 get_frame_size (&width, &height);
9921 if (width != old_width || height != old_height)
9922 change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);
9923
9924 /* Run suspend-resume-hook. */
9925 if (!NILP (Vrun_hooks))
9926 call1 (Vrun_hooks, intern ("suspend-resume-hook"));
9927
9928 UNGCPRO;
9929 return Qnil;
9930 }
9931
9932 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
9933 Then in any case stuff anything Emacs has read ahead and not used. */
9934
9935 void
9936 stuff_buffered_input (stuffstring)
9937 Lisp_Object stuffstring;
9938 {
9939 /* stuff_char works only in BSD, versions 4.2 and up. */
9940 #ifdef BSD_SYSTEM
9941 #ifndef BSD4_1
9942 register unsigned char *p;
9943
9944 if (STRINGP (stuffstring))
9945 {
9946 register int count;
9947
9948 p = SDATA (stuffstring);
9949 count = SBYTES (stuffstring);
9950 while (count-- > 0)
9951 stuff_char (*p++);
9952 stuff_char ('\n');
9953 }
9954
9955 /* Anything we have read ahead, put back for the shell to read. */
9956 /* ?? What should this do when we have multiple keyboards??
9957 Should we ignore anything that was typed in at the "wrong" kboard? */
9958 for (; kbd_fetch_ptr != kbd_store_ptr; kbd_fetch_ptr++)
9959 {
9960 int idx;
9961
9962 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
9963 kbd_fetch_ptr = kbd_buffer;
9964 if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
9965 stuff_char (kbd_fetch_ptr->code);
9966
9967 kbd_fetch_ptr->kind = NO_EVENT;
9968 idx = 2 * (kbd_fetch_ptr - kbd_buffer);
9969 ASET (kbd_buffer_gcpro, idx, Qnil);
9970 ASET (kbd_buffer_gcpro, idx + 1, Qnil);
9971 }
9972
9973 input_pending = 0;
9974 #endif
9975 #endif /* BSD_SYSTEM and not BSD4_1 */
9976 }
9977 \f
9978 void
9979 set_waiting_for_input (time_to_clear)
9980 EMACS_TIME *time_to_clear;
9981 {
9982 input_available_clear_time = time_to_clear;
9983
9984 /* Tell interrupt_signal to throw back to read_char, */
9985 waiting_for_input = 1;
9986
9987 /* If interrupt_signal was called before and buffered a C-g,
9988 make it run again now, to avoid timing error. */
9989 if (!NILP (Vquit_flag))
9990 quit_throw_to_read_char ();
9991 }
9992
9993 void
9994 clear_waiting_for_input ()
9995 {
9996 /* Tell interrupt_signal not to throw back to read_char, */
9997 waiting_for_input = 0;
9998 input_available_clear_time = 0;
9999 }
10000
10001 /* This routine is called at interrupt level in response to C-g.
10002
10003 If interrupt_input, this is the handler for SIGINT. Otherwise, it
10004 is called from kbd_buffer_store_event, in handling SIGIO or
10005 SIGTINT.
10006
10007 If `waiting_for_input' is non zero, then unless `echoing' is
10008 nonzero, immediately throw back to read_char.
10009
10010 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10011 eval to throw, when it gets a chance. If quit-flag is already
10012 non-nil, it stops the job right away. */
10013
10014 SIGTYPE
10015 interrupt_signal (signalnum) /* If we don't have an argument, */
10016 int signalnum; /* some compilers complain in signal calls. */
10017 {
10018 char c;
10019 /* Must preserve main program's value of errno. */
10020 int old_errno = errno;
10021 struct frame *sf = SELECTED_FRAME ();
10022
10023 #if defined (USG) && !defined (POSIX_SIGNALS)
10024 if (!read_socket_hook && NILP (Vwindow_system))
10025 {
10026 /* USG systems forget handlers when they are used;
10027 must reestablish each time */
10028 signal (SIGINT, interrupt_signal);
10029 signal (SIGQUIT, interrupt_signal);
10030 }
10031 #endif /* USG */
10032
10033 cancel_echoing ();
10034
10035 if (!NILP (Vquit_flag)
10036 && (FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf)))
10037 {
10038 /* If SIGINT isn't blocked, don't let us be interrupted by
10039 another SIGINT, it might be harmful due to non-reentrancy
10040 in I/O functions. */
10041 sigblock (sigmask (SIGINT));
10042
10043 fflush (stdout);
10044 reset_sys_modes ();
10045
10046 #ifdef SIGTSTP /* Support possible in later USG versions */
10047 /*
10048 * On systems which can suspend the current process and return to the original
10049 * shell, this command causes the user to end up back at the shell.
10050 * The "Auto-save" and "Abort" questions are not asked until
10051 * the user elects to return to emacs, at which point he can save the current
10052 * job and either dump core or continue.
10053 */
10054 sys_suspend ();
10055 #else
10056 #ifdef VMS
10057 if (sys_suspend () == -1)
10058 {
10059 printf ("Not running as a subprocess;\n");
10060 printf ("you can continue or abort.\n");
10061 }
10062 #else /* not VMS */
10063 /* Perhaps should really fork an inferior shell?
10064 But that would not provide any way to get back
10065 to the original shell, ever. */
10066 printf ("No support for stopping a process on this operating system;\n");
10067 printf ("you can continue or abort.\n");
10068 #endif /* not VMS */
10069 #endif /* not SIGTSTP */
10070 #ifdef MSDOS
10071 /* We must remain inside the screen area when the internal terminal
10072 is used. Note that [Enter] is not echoed by dos. */
10073 cursor_to (0, 0);
10074 #endif
10075 /* It doesn't work to autosave while GC is in progress;
10076 the code used for auto-saving doesn't cope with the mark bit. */
10077 if (!gc_in_progress)
10078 {
10079 printf ("Auto-save? (y or n) ");
10080 fflush (stdout);
10081 if (((c = getchar ()) & ~040) == 'Y')
10082 {
10083 Fdo_auto_save (Qt, Qnil);
10084 #ifdef MSDOS
10085 printf ("\r\nAuto-save done");
10086 #else /* not MSDOS */
10087 printf ("Auto-save done\n");
10088 #endif /* not MSDOS */
10089 }
10090 while (c != '\n') c = getchar ();
10091 }
10092 else
10093 {
10094 /* During GC, it must be safe to reenable quitting again. */
10095 Vinhibit_quit = Qnil;
10096 #ifdef MSDOS
10097 printf ("\r\n");
10098 #endif /* not MSDOS */
10099 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10100 printf ("but will instead do a real quit after garbage collection ends\r\n");
10101 fflush (stdout);
10102 }
10103
10104 #ifdef MSDOS
10105 printf ("\r\nAbort? (y or n) ");
10106 #else /* not MSDOS */
10107 #ifdef VMS
10108 printf ("Abort (and enter debugger)? (y or n) ");
10109 #else /* not VMS */
10110 printf ("Abort (and dump core)? (y or n) ");
10111 #endif /* not VMS */
10112 #endif /* not MSDOS */
10113 fflush (stdout);
10114 if (((c = getchar ()) & ~040) == 'Y')
10115 abort ();
10116 while (c != '\n') c = getchar ();
10117 #ifdef MSDOS
10118 printf ("\r\nContinuing...\r\n");
10119 #else /* not MSDOS */
10120 printf ("Continuing...\n");
10121 #endif /* not MSDOS */
10122 fflush (stdout);
10123 init_sys_modes ();
10124 sigfree ();
10125 }
10126 else
10127 {
10128 /* If executing a function that wants to be interrupted out of
10129 and the user has not deferred quitting by binding `inhibit-quit'
10130 then quit right away. */
10131 if (immediate_quit && NILP (Vinhibit_quit))
10132 {
10133 struct gl_state_s saved;
10134 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
10135
10136 immediate_quit = 0;
10137 sigfree ();
10138 saved = gl_state;
10139 GCPRO4 (saved.object, saved.global_code,
10140 saved.current_syntax_table, saved.old_prop);
10141 Fsignal (Qquit, Qnil);
10142 gl_state = saved;
10143 UNGCPRO;
10144 }
10145 else
10146 /* Else request quit when it's safe */
10147 Vquit_flag = Qt;
10148 }
10149
10150 if (waiting_for_input && !echoing)
10151 quit_throw_to_read_char ();
10152
10153 errno = old_errno;
10154 }
10155
10156 /* Handle a C-g by making read_char return C-g. */
10157
10158 void
10159 quit_throw_to_read_char ()
10160 {
10161 sigfree ();
10162 /* Prevent another signal from doing this before we finish. */
10163 clear_waiting_for_input ();
10164 input_pending = 0;
10165
10166 Vunread_command_events = Qnil;
10167 unread_command_char = -1;
10168
10169 #if 0 /* Currently, sit_for is called from read_char without turning
10170 off polling. And that can call set_waiting_for_input.
10171 It seems to be harmless. */
10172 #ifdef POLL_FOR_INPUT
10173 /* May be > 1 if in recursive minibuffer. */
10174 if (poll_suppress_count == 0)
10175 abort ();
10176 #endif
10177 #endif
10178 if (FRAMEP (internal_last_event_frame)
10179 && !EQ (internal_last_event_frame, selected_frame))
10180 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame),
10181 0, 0);
10182
10183 _longjmp (getcjmp, 1);
10184 }
10185 \f
10186 DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
10187 doc: /* Set mode of reading keyboard input.
10188 First arg INTERRUPT non-nil means use input interrupts;
10189 nil means use CBREAK mode.
10190 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10191 (no effect except in CBREAK mode).
10192 Third arg META t means accept 8-bit input (for a Meta key).
10193 META nil means ignore the top bit, on the assumption it is parity.
10194 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10195 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10196 See also `current-input-mode'. */)
10197 (interrupt, flow, meta, quit)
10198 Lisp_Object interrupt, flow, meta, quit;
10199 {
10200 if (!NILP (quit)
10201 && (!INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400))
10202 error ("set-input-mode: QUIT must be an ASCII character");
10203
10204 #ifdef POLL_FOR_INPUT
10205 stop_polling ();
10206 #endif
10207
10208 #ifndef DOS_NT
10209 /* this causes startup screen to be restored and messes with the mouse */
10210 reset_sys_modes ();
10211 #endif
10212
10213 #ifdef SIGIO
10214 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10215 if (read_socket_hook)
10216 {
10217 /* When using X, don't give the user a real choice,
10218 because we haven't implemented the mechanisms to support it. */
10219 #ifdef NO_SOCK_SIGIO
10220 interrupt_input = 0;
10221 #else /* not NO_SOCK_SIGIO */
10222 interrupt_input = 1;
10223 #endif /* NO_SOCK_SIGIO */
10224 }
10225 else
10226 interrupt_input = !NILP (interrupt);
10227 #else /* not SIGIO */
10228 interrupt_input = 0;
10229 #endif /* not SIGIO */
10230
10231 /* Our VMS input only works by interrupts, as of now. */
10232 #ifdef VMS
10233 interrupt_input = 1;
10234 #endif
10235
10236 flow_control = !NILP (flow);
10237 if (NILP (meta))
10238 meta_key = 0;
10239 else if (EQ (meta, Qt))
10240 meta_key = 1;
10241 else
10242 meta_key = 2;
10243 if (!NILP (quit))
10244 /* Don't let this value be out of range. */
10245 quit_char = XINT (quit) & (meta_key ? 0377 : 0177);
10246
10247 #ifndef DOS_NT
10248 init_sys_modes ();
10249 #endif
10250
10251 #ifdef POLL_FOR_INPUT
10252 poll_suppress_count = 1;
10253 start_polling ();
10254 #endif
10255 return Qnil;
10256 }
10257
10258 DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
10259 doc: /* Return information about the way Emacs currently reads keyboard input.
10260 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10261 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10262 nil, Emacs is using CBREAK mode.
10263 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10264 terminal; this does not apply if Emacs uses interrupt-driven input.
10265 META is t if accepting 8-bit input with 8th bit as Meta flag.
10266 META nil means ignoring the top bit, on the assumption it is parity.
10267 META is neither t nor nil if accepting 8-bit input and using
10268 all 8 bits as the character code.
10269 QUIT is the character Emacs currently uses to quit.
10270 The elements of this list correspond to the arguments of
10271 `set-input-mode'. */)
10272 ()
10273 {
10274 Lisp_Object val[4];
10275
10276 val[0] = interrupt_input ? Qt : Qnil;
10277 val[1] = flow_control ? Qt : Qnil;
10278 val[2] = meta_key == 2 ? make_number (0) : meta_key == 1 ? Qt : Qnil;
10279 XSETFASTINT (val[3], quit_char);
10280
10281 return Flist (sizeof (val) / sizeof (val[0]), val);
10282 }
10283
10284 \f
10285 /*
10286 * Set up a new kboard object with reasonable initial values.
10287 */
10288 void
10289 init_kboard (kb)
10290 KBOARD *kb;
10291 {
10292 kb->Voverriding_terminal_local_map = Qnil;
10293 kb->Vlast_command = Qnil;
10294 kb->Vreal_last_command = Qnil;
10295 kb->Vprefix_arg = Qnil;
10296 kb->Vlast_prefix_arg = Qnil;
10297 kb->kbd_queue = Qnil;
10298 kb->kbd_queue_has_data = 0;
10299 kb->immediate_echo = 0;
10300 kb->echo_string = Qnil;
10301 kb->echo_after_prompt = -1;
10302 kb->kbd_macro_buffer = 0;
10303 kb->kbd_macro_bufsize = 0;
10304 kb->defining_kbd_macro = Qnil;
10305 kb->Vlast_kbd_macro = Qnil;
10306 kb->reference_count = 0;
10307 kb->Vsystem_key_alist = Qnil;
10308 kb->system_key_syms = Qnil;
10309 kb->Vdefault_minibuffer_frame = Qnil;
10310 }
10311
10312 /*
10313 * Destroy the contents of a kboard object, but not the object itself.
10314 * We use this just before deleting it, or if we're going to initialize
10315 * it a second time.
10316 */
10317 static void
10318 wipe_kboard (kb)
10319 KBOARD *kb;
10320 {
10321 if (kb->kbd_macro_buffer)
10322 xfree (kb->kbd_macro_buffer);
10323 }
10324
10325 #ifdef MULTI_KBOARD
10326
10327 /* Free KB and memory referenced from it. */
10328
10329 void
10330 delete_kboard (kb)
10331 KBOARD *kb;
10332 {
10333 KBOARD **kbp;
10334
10335 for (kbp = &all_kboards; *kbp != kb; kbp = &(*kbp)->next_kboard)
10336 if (*kbp == NULL)
10337 abort ();
10338 *kbp = kb->next_kboard;
10339
10340 /* Prevent a dangling reference to KB. */
10341 if (kb == current_kboard
10342 && FRAMEP (selected_frame)
10343 && FRAME_LIVE_P (XFRAME (selected_frame)))
10344 {
10345 current_kboard = XFRAME (selected_frame)->kboard;
10346 if (current_kboard == kb)
10347 abort ();
10348 }
10349
10350 wipe_kboard (kb);
10351 xfree (kb);
10352 }
10353
10354 #endif /* MULTI_KBOARD */
10355
10356 void
10357 init_keyboard ()
10358 {
10359 /* This is correct before outermost invocation of the editor loop */
10360 command_loop_level = -1;
10361 immediate_quit = 0;
10362 quit_char = Ctl ('g');
10363 Vunread_command_events = Qnil;
10364 unread_command_char = -1;
10365 EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1);
10366 total_keys = 0;
10367 recent_keys_index = 0;
10368 kbd_fetch_ptr = kbd_buffer;
10369 kbd_store_ptr = kbd_buffer;
10370 kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
10371 #ifdef HAVE_MOUSE
10372 do_mouse_tracking = Qnil;
10373 #endif
10374 input_pending = 0;
10375
10376 /* This means that command_loop_1 won't try to select anything the first
10377 time through. */
10378 internal_last_event_frame = Qnil;
10379 Vlast_event_frame = internal_last_event_frame;
10380
10381 #ifdef MULTI_KBOARD
10382 current_kboard = initial_kboard;
10383 #endif
10384 wipe_kboard (current_kboard);
10385 init_kboard (current_kboard);
10386
10387 if (!noninteractive && !read_socket_hook && NILP (Vwindow_system))
10388 {
10389 signal (SIGINT, interrupt_signal);
10390 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
10391 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10392 SIGQUIT and we can't tell which one it will give us. */
10393 signal (SIGQUIT, interrupt_signal);
10394 #endif /* HAVE_TERMIO */
10395 }
10396 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10397 #ifdef SIGIO
10398 if (!noninteractive)
10399 signal (SIGIO, input_available_signal);
10400 #endif /* SIGIO */
10401
10402 /* Use interrupt input by default, if it works and noninterrupt input
10403 has deficiencies. */
10404
10405 #ifdef INTERRUPT_INPUT
10406 interrupt_input = 1;
10407 #else
10408 interrupt_input = 0;
10409 #endif
10410
10411 /* Our VMS input only works by interrupts, as of now. */
10412 #ifdef VMS
10413 interrupt_input = 1;
10414 #endif
10415
10416 sigfree ();
10417 dribble = 0;
10418
10419 if (keyboard_init_hook)
10420 (*keyboard_init_hook) ();
10421
10422 #ifdef POLL_FOR_INPUT
10423 poll_suppress_count = 1;
10424 start_polling ();
10425 #endif
10426 }
10427
10428 /* This type's only use is in syms_of_keyboard, to initialize the
10429 event header symbols and put properties on them. */
10430 struct event_head {
10431 Lisp_Object *var;
10432 char *name;
10433 Lisp_Object *kind;
10434 };
10435
10436 struct event_head head_table[] = {
10437 {&Qmouse_movement, "mouse-movement", &Qmouse_movement},
10438 {&Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement},
10439 {&Qswitch_frame, "switch-frame", &Qswitch_frame},
10440 {&Qdelete_frame, "delete-frame", &Qdelete_frame},
10441 {&Qiconify_frame, "iconify-frame", &Qiconify_frame},
10442 {&Qmake_frame_visible, "make-frame-visible", &Qmake_frame_visible},
10443 {&Qselect_window, "select-window", &Qselect_window}
10444 };
10445
10446 void
10447 syms_of_keyboard ()
10448 {
10449 Vpre_help_message = Qnil;
10450 staticpro (&Vpre_help_message);
10451
10452 Vlispy_mouse_stem = build_string ("mouse");
10453 staticpro (&Vlispy_mouse_stem);
10454
10455 /* Tool-bars. */
10456 QCimage = intern (":image");
10457 staticpro (&QCimage);
10458
10459 staticpro (&Qhelp_echo);
10460 Qhelp_echo = intern ("help-echo");
10461
10462 staticpro (&item_properties);
10463 item_properties = Qnil;
10464
10465 staticpro (&tool_bar_item_properties);
10466 tool_bar_item_properties = Qnil;
10467 staticpro (&tool_bar_items_vector);
10468 tool_bar_items_vector = Qnil;
10469
10470 staticpro (&real_this_command);
10471 real_this_command = Qnil;
10472
10473 Qtimer_event_handler = intern ("timer-event-handler");
10474 staticpro (&Qtimer_event_handler);
10475
10476 Qdisabled_command_hook = intern ("disabled-command-hook");
10477 staticpro (&Qdisabled_command_hook);
10478
10479 Qself_insert_command = intern ("self-insert-command");
10480 staticpro (&Qself_insert_command);
10481
10482 Qforward_char = intern ("forward-char");
10483 staticpro (&Qforward_char);
10484
10485 Qbackward_char = intern ("backward-char");
10486 staticpro (&Qbackward_char);
10487
10488 Qdisabled = intern ("disabled");
10489 staticpro (&Qdisabled);
10490
10491 Qundefined = intern ("undefined");
10492 staticpro (&Qundefined);
10493
10494 Qpre_command_hook = intern ("pre-command-hook");
10495 staticpro (&Qpre_command_hook);
10496
10497 Qpost_command_hook = intern ("post-command-hook");
10498 staticpro (&Qpost_command_hook);
10499
10500 Qpost_command_idle_hook = intern ("post-command-idle-hook");
10501 staticpro (&Qpost_command_idle_hook);
10502
10503 Qdeferred_action_function = intern ("deferred-action-function");
10504 staticpro (&Qdeferred_action_function);
10505
10506 Qcommand_hook_internal = intern ("command-hook-internal");
10507 staticpro (&Qcommand_hook_internal);
10508
10509 Qfunction_key = intern ("function-key");
10510 staticpro (&Qfunction_key);
10511 Qmouse_click = intern ("mouse-click");
10512 staticpro (&Qmouse_click);
10513 #if defined(WINDOWSNT) || defined(MAC_OSX)
10514 Qmouse_wheel = intern ("mouse-wheel");
10515 staticpro (&Qmouse_wheel);
10516 #endif
10517 #ifdef WINDOWSNT
10518 Qlanguage_change = intern ("language-change");
10519 staticpro (&Qlanguage_change);
10520 #endif
10521 Qdrag_n_drop = intern ("drag-n-drop");
10522 staticpro (&Qdrag_n_drop);
10523
10524 Qsave_session = intern ("save-session");
10525 staticpro(&Qsave_session);
10526
10527 Qusr1_signal = intern ("usr1-signal");
10528 staticpro (&Qusr1_signal);
10529 Qusr2_signal = intern ("usr2-signal");
10530 staticpro (&Qusr2_signal);
10531
10532 Qmenu_enable = intern ("menu-enable");
10533 staticpro (&Qmenu_enable);
10534 Qmenu_alias = intern ("menu-alias");
10535 staticpro (&Qmenu_alias);
10536 QCenable = intern (":enable");
10537 staticpro (&QCenable);
10538 QCvisible = intern (":visible");
10539 staticpro (&QCvisible);
10540 QChelp = intern (":help");
10541 staticpro (&QChelp);
10542 QCfilter = intern (":filter");
10543 staticpro (&QCfilter);
10544 QCbutton = intern (":button");
10545 staticpro (&QCbutton);
10546 QCkeys = intern (":keys");
10547 staticpro (&QCkeys);
10548 QCkey_sequence = intern (":key-sequence");
10549 staticpro (&QCkey_sequence);
10550 QCtoggle = intern (":toggle");
10551 staticpro (&QCtoggle);
10552 QCradio = intern (":radio");
10553 staticpro (&QCradio);
10554
10555 Qmode_line = intern ("mode-line");
10556 staticpro (&Qmode_line);
10557 Qvertical_line = intern ("vertical-line");
10558 staticpro (&Qvertical_line);
10559 Qvertical_scroll_bar = intern ("vertical-scroll-bar");
10560 staticpro (&Qvertical_scroll_bar);
10561 Qmenu_bar = intern ("menu-bar");
10562 staticpro (&Qmenu_bar);
10563
10564 Qabove_handle = intern ("above-handle");
10565 staticpro (&Qabove_handle);
10566 Qhandle = intern ("handle");
10567 staticpro (&Qhandle);
10568 Qbelow_handle = intern ("below-handle");
10569 staticpro (&Qbelow_handle);
10570 Qup = intern ("up");
10571 staticpro (&Qup);
10572 Qdown = intern ("down");
10573 staticpro (&Qdown);
10574 Qtop = intern ("top");
10575 staticpro (&Qtop);
10576 Qbottom = intern ("bottom");
10577 staticpro (&Qbottom);
10578 Qend_scroll = intern ("end-scroll");
10579 staticpro (&Qend_scroll);
10580 Qratio = intern ("ratio");
10581 staticpro (&Qratio);
10582
10583 Qevent_kind = intern ("event-kind");
10584 staticpro (&Qevent_kind);
10585 Qevent_symbol_elements = intern ("event-symbol-elements");
10586 staticpro (&Qevent_symbol_elements);
10587 Qevent_symbol_element_mask = intern ("event-symbol-element-mask");
10588 staticpro (&Qevent_symbol_element_mask);
10589 Qmodifier_cache = intern ("modifier-cache");
10590 staticpro (&Qmodifier_cache);
10591
10592 Qrecompute_lucid_menubar = intern ("recompute-lucid-menubar");
10593 staticpro (&Qrecompute_lucid_menubar);
10594 Qactivate_menubar_hook = intern ("activate-menubar-hook");
10595 staticpro (&Qactivate_menubar_hook);
10596
10597 Qpolling_period = intern ("polling-period");
10598 staticpro (&Qpolling_period);
10599
10600 Qinput_method_function = intern ("input-method-function");
10601 staticpro (&Qinput_method_function);
10602
10603 Qinput_method_exit_on_first_char = intern ("input-method-exit-on-first-char");
10604 staticpro (&Qinput_method_exit_on_first_char);
10605 Qinput_method_use_echo_area = intern ("input-method-use-echo-area");
10606 staticpro (&Qinput_method_use_echo_area);
10607
10608 Fset (Qinput_method_exit_on_first_char, Qnil);
10609 Fset (Qinput_method_use_echo_area, Qnil);
10610
10611 last_point_position_buffer = Qnil;
10612
10613 {
10614 struct event_head *p;
10615
10616 for (p = head_table;
10617 p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
10618 p++)
10619 {
10620 *p->var = intern (p->name);
10621 staticpro (p->var);
10622 Fput (*p->var, Qevent_kind, *p->kind);
10623 Fput (*p->var, Qevent_symbol_elements, Fcons (*p->var, Qnil));
10624 }
10625 }
10626
10627 button_down_location = Fmake_vector (make_number (1), Qnil);
10628 staticpro (&button_down_location);
10629 mouse_syms = Fmake_vector (make_number (1), Qnil);
10630 staticpro (&mouse_syms);
10631
10632 {
10633 int i;
10634 int len = sizeof (modifier_names) / sizeof (modifier_names[0]);
10635
10636 modifier_symbols = Fmake_vector (make_number (len), Qnil);
10637 for (i = 0; i < len; i++)
10638 if (modifier_names[i])
10639 XVECTOR (modifier_symbols)->contents[i] = intern (modifier_names[i]);
10640 staticpro (&modifier_symbols);
10641 }
10642
10643 recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
10644 staticpro (&recent_keys);
10645
10646 this_command_keys = Fmake_vector (make_number (40), Qnil);
10647 staticpro (&this_command_keys);
10648
10649 raw_keybuf = Fmake_vector (make_number (30), Qnil);
10650 staticpro (&raw_keybuf);
10651
10652 Qextended_command_history = intern ("extended-command-history");
10653 Fset (Qextended_command_history, Qnil);
10654 staticpro (&Qextended_command_history);
10655
10656 kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
10657 staticpro (&kbd_buffer_gcpro);
10658
10659 accent_key_syms = Qnil;
10660 staticpro (&accent_key_syms);
10661
10662 func_key_syms = Qnil;
10663 staticpro (&func_key_syms);
10664
10665 #if defined(WINDOWSNT) || defined(MAC_OSX)
10666 mouse_wheel_syms = Qnil;
10667 staticpro (&mouse_wheel_syms);
10668 drag_n_drop_syms = Qnil;
10669 staticpro (&drag_n_drop_syms);
10670 #endif
10671
10672 unread_switch_frame = Qnil;
10673 staticpro (&unread_switch_frame);
10674
10675 internal_last_event_frame = Qnil;
10676 staticpro (&internal_last_event_frame);
10677
10678 read_key_sequence_cmd = Qnil;
10679 staticpro (&read_key_sequence_cmd);
10680
10681 menu_bar_one_keymap_changed_items = Qnil;
10682 staticpro (&menu_bar_one_keymap_changed_items);
10683
10684 defsubr (&Sevent_convert_list);
10685 defsubr (&Sread_key_sequence);
10686 defsubr (&Sread_key_sequence_vector);
10687 defsubr (&Srecursive_edit);
10688 #ifdef HAVE_MOUSE
10689 defsubr (&Strack_mouse);
10690 #endif
10691 defsubr (&Sinput_pending_p);
10692 defsubr (&Scommand_execute);
10693 defsubr (&Srecent_keys);
10694 defsubr (&Sthis_command_keys);
10695 defsubr (&Sthis_command_keys_vector);
10696 defsubr (&Sthis_single_command_keys);
10697 defsubr (&Sthis_single_command_raw_keys);
10698 defsubr (&Sreset_this_command_lengths);
10699 defsubr (&Sclear_this_command_keys);
10700 defsubr (&Ssuspend_emacs);
10701 defsubr (&Sabort_recursive_edit);
10702 defsubr (&Sexit_recursive_edit);
10703 defsubr (&Srecursion_depth);
10704 defsubr (&Stop_level);
10705 defsubr (&Sdiscard_input);
10706 defsubr (&Sopen_dribble_file);
10707 defsubr (&Sset_input_mode);
10708 defsubr (&Scurrent_input_mode);
10709 defsubr (&Sexecute_extended_command);
10710
10711 DEFVAR_LISP ("last-command-char", &last_command_char,
10712 doc: /* Last input event that was part of a command. */);
10713
10714 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char,
10715 doc: /* Last input event that was part of a command. */);
10716
10717 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
10718 doc: /* Last input event in a command, except for mouse menu events.
10719 Mouse menus give back keys that don't look like mouse events;
10720 this variable holds the actual mouse event that led to the menu,
10721 so that you can determine whether the command was run by mouse or not. */);
10722
10723 DEFVAR_LISP ("last-input-char", &last_input_char,
10724 doc: /* Last input event. */);
10725
10726 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char,
10727 doc: /* Last input event. */);
10728
10729 DEFVAR_LISP ("unread-command-events", &Vunread_command_events,
10730 doc: /* List of events to be read as the command input.
10731 These events are processed first, before actual keyboard input. */);
10732 Vunread_command_events = Qnil;
10733
10734 DEFVAR_INT ("unread-command-char", &unread_command_char,
10735 doc: /* If not -1, an object to be read as next command input event. */);
10736
10737 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events,
10738 doc: /* List of events to be processed as input by input methods.
10739 These events are processed after `unread-command-events', but
10740 before actual keyboard input. */);
10741 Vunread_post_input_method_events = Qnil;
10742
10743 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events,
10744 doc: /* List of events to be processed as input by input methods.
10745 These events are processed after `unread-command-events', but
10746 before actual keyboard input. */);
10747 Vunread_input_method_events = Qnil;
10748
10749 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char,
10750 doc: /* Meta-prefix character code.
10751 Meta-foo as command input turns into this character followed by foo. */);
10752 XSETINT (meta_prefix_char, 033);
10753
10754 DEFVAR_KBOARD ("last-command", Vlast_command,
10755 doc: /* The last command executed.
10756 Normally a symbol with a function definition, but can be whatever was found
10757 in the keymap, or whatever the variable `this-command' was set to by that
10758 command.
10759
10760 The value `mode-exit' is special; it means that the previous command
10761 read an event that told it to exit, and it did so and unread that event.
10762 In other words, the present command is the event that made the previous
10763 command exit.
10764
10765 The value `kill-region' is special; it means that the previous command
10766 was a kill command. */);
10767
10768 DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
10769 doc: /* Same as `last-command', but never altered by Lisp code. */);
10770
10771 DEFVAR_LISP ("this-command", &Vthis_command,
10772 doc: /* The command now being executed.
10773 The command can set this variable; whatever is put here
10774 will be in `last-command' during the following command. */);
10775 Vthis_command = Qnil;
10776
10777 DEFVAR_LISP ("this-original-command", &Vthis_original_command,
10778 doc: /* If non-nil, the original command bound to the current key sequence.
10779 The value of `this-command' is the result of looking up the original
10780 command in the active keymaps. */);
10781 Vthis_original_command = Qnil;
10782
10783 DEFVAR_INT ("auto-save-interval", &auto_save_interval,
10784 doc: /* *Number of input events between auto-saves.
10785 Zero means disable autosaving due to number of characters typed. */);
10786 auto_save_interval = 300;
10787
10788 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout,
10789 doc: /* *Number of seconds idle time before auto-save.
10790 Zero or nil means disable auto-saving due to idleness.
10791 After auto-saving due to this many seconds of idle time,
10792 Emacs also does a garbage collection if that seems to be warranted. */);
10793 XSETFASTINT (Vauto_save_timeout, 30);
10794
10795 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes,
10796 doc: /* *Nonzero means echo unfinished commands after this many seconds of pause.
10797 The value may be integer or floating point. */);
10798 Vecho_keystrokes = make_number (1);
10799
10800 DEFVAR_INT ("polling-period", &polling_period,
10801 doc: /* *Interval between polling for input during Lisp execution.
10802 The reason for polling is to make C-g work to stop a running program.
10803 Polling is needed only when using X windows and SIGIO does not work.
10804 Polling is automatically disabled in all other cases. */);
10805 polling_period = 2;
10806
10807 DEFVAR_LISP ("double-click-time", &Vdouble_click_time,
10808 doc: /* *Maximum time between mouse clicks to make a double-click.
10809 Measured in milliseconds. nil means disable double-click recognition;
10810 t means double-clicks have no time limit and are detected
10811 by position only. */);
10812 Vdouble_click_time = make_number (500);
10813
10814 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz,
10815 doc: /* *Maximum mouse movement between clicks to make a double-click.
10816 On window-system frames, value is the number of pixels the mouse may have
10817 moved horizontally or vertically between two clicks to make a double-click.
10818 On non window-system frames, value is interpreted in units of 1/8 characters
10819 instead of pixels.
10820
10821 This variable is also the threshold for motion of the mouse
10822 to count as a drag. */);
10823 double_click_fuzz = 3;
10824
10825 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus,
10826 doc: /* *Non-nil means inhibit local map menu bar menus. */);
10827 inhibit_local_menu_bar_menus = 0;
10828
10829 DEFVAR_INT ("num-input-keys", &num_input_keys,
10830 doc: /* Number of complete key sequences read as input so far.
10831 This includes key sequences read from keyboard macros.
10832 The number is effectively the number of interactive command invocations. */);
10833 num_input_keys = 0;
10834
10835 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events,
10836 doc: /* Number of input events read from the keyboard so far.
10837 This does not include events generated by keyboard macros. */);
10838 num_nonmacro_input_events = 0;
10839
10840 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
10841 doc: /* The frame in which the most recently read event occurred.
10842 If the last event came from a keyboard macro, this is set to `macro'. */);
10843 Vlast_event_frame = Qnil;
10844
10845 /* This variable is set up in sysdep.c. */
10846 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char,
10847 doc: /* The ERASE character as set by the user with stty. */);
10848
10849 DEFVAR_LISP ("help-char", &Vhelp_char,
10850 doc: /* Character to recognize as meaning Help.
10851 When it is read, do `(eval help-form)', and display result if it's a string.
10852 If the value of `help-form' is nil, this char can be read normally. */);
10853 XSETINT (Vhelp_char, Ctl ('H'));
10854
10855 DEFVAR_LISP ("help-event-list", &Vhelp_event_list,
10856 doc: /* List of input events to recognize as meaning Help.
10857 These work just like the value of `help-char' (see that). */);
10858 Vhelp_event_list = Qnil;
10859
10860 DEFVAR_LISP ("help-form", &Vhelp_form,
10861 doc: /* Form to execute when character `help-char' is read.
10862 If the form returns a string, that string is displayed.
10863 If `help-form' is nil, the help char is not recognized. */);
10864 Vhelp_form = Qnil;
10865
10866 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command,
10867 doc: /* Command to run when `help-char' character follows a prefix key.
10868 This command is used only when there is no actual binding
10869 for that character after that prefix key. */);
10870 Vprefix_help_command = Qnil;
10871
10872 DEFVAR_LISP ("top-level", &Vtop_level,
10873 doc: /* Form to evaluate when Emacs starts up.
10874 Useful to set before you dump a modified Emacs. */);
10875 Vtop_level = Qnil;
10876
10877 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table,
10878 doc: /* Translate table for keyboard input, or nil.
10879 Each character is looked up in this string and the contents used instead.
10880 The value may be a string, a vector, or a char-table.
10881 If it is a string or vector of length N,
10882 character codes N and up are untranslated.
10883 In a vector or a char-table, an element which is nil means "no translation". */);
10884 Vkeyboard_translate_table = Qnil;
10885
10886 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
10887 doc: /* Non-nil means to always spawn a subshell instead of suspending.
10888 \(Even if the operating system has support for stopping a process.\) */);
10889 cannot_suspend = 0;
10890
10891 DEFVAR_BOOL ("menu-prompting", &menu_prompting,
10892 doc: /* Non-nil means prompt with menus when appropriate.
10893 This is done when reading from a keymap that has a prompt string,
10894 for elements that have prompt strings.
10895 The menu is displayed on the screen
10896 if X menus were enabled at configuration
10897 time and the previous event was a mouse click prefix key.
10898 Otherwise, menu prompting uses the echo area. */);
10899 menu_prompting = 1;
10900
10901 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,
10902 doc: /* Character to see next line of menu prompt.
10903 Type this character while in a menu prompt to rotate around the lines of it. */);
10904 XSETINT (menu_prompt_more_char, ' ');
10905
10906 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers,
10907 doc: /* A mask of additional modifier keys to use with every keyboard character.
10908 Emacs applies the modifiers of the character stored here to each keyboard
10909 character it reads. For example, after evaluating the expression
10910 (setq extra-keyboard-modifiers ?\\C-x)
10911 all input characters will have the control modifier applied to them.
10912
10913 Note that the character ?\\C-@, equivalent to the integer zero, does
10914 not count as a control character; rather, it counts as a character
10915 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
10916 cancels any modification. */);
10917 extra_keyboard_modifiers = 0;
10918
10919 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark,
10920 doc: /* If an editing command sets this to t, deactivate the mark afterward.
10921 The command loop sets this to nil before each command,
10922 and tests the value when the command returns.
10923 Buffer modification stores t in this variable. */);
10924 Vdeactivate_mark = Qnil;
10925
10926 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
10927 doc: /* Temporary storage of pre-command-hook or post-command-hook. */);
10928 Vcommand_hook_internal = Qnil;
10929
10930 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook,
10931 doc: /* Normal hook run before each command is executed.
10932 If an unhandled error happens in running this hook,
10933 the hook value is set to nil, since otherwise the error
10934 might happen repeatedly and make Emacs nonfunctional. */);
10935 Vpre_command_hook = Qnil;
10936
10937 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook,
10938 doc: /* Normal hook run after each command is executed.
10939 If an unhandled error happens in running this hook,
10940 the hook value is set to nil, since otherwise the error
10941 might happen repeatedly and make Emacs nonfunctional. */);
10942 Vpost_command_hook = Qnil;
10943
10944 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook,
10945 doc: /* Normal hook run after each command is executed, if idle.
10946 Errors running the hook are caught and ignored. */);
10947 Vpost_command_idle_hook = Qnil;
10948
10949 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay,
10950 doc: /* Delay time before running `post-command-idle-hook'.
10951 This is measured in microseconds. */);
10952 post_command_idle_delay = 100000;
10953
10954 #if 0
10955 DEFVAR_LISP ("echo-area-clear-hook", ...,
10956 doc: /* Normal hook run when clearing the echo area. */);
10957 #endif
10958 Qecho_area_clear_hook = intern ("echo-area-clear-hook");
10959 SET_SYMBOL_VALUE (Qecho_area_clear_hook, Qnil);
10960
10961 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag,
10962 doc: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
10963 Vlucid_menu_bar_dirty_flag = Qnil;
10964
10965 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items,
10966 doc: /* List of menu bar items to move to the end of the menu bar.
10967 The elements of the list are event types that may have menu bar bindings. */);
10968 Vmenu_bar_final_items = Qnil;
10969
10970 DEFVAR_KBOARD ("overriding-terminal-local-map",
10971 Voverriding_terminal_local_map,
10972 doc: /* Per-terminal keymap that overrides all other local keymaps.
10973 If this variable is non-nil, it is used as a keymap instead of the
10974 buffer's local map, and the minor mode keymaps and text property keymaps.
10975 This variable is intended to let commands such as `universal-argument'
10976 set up a different keymap for reading the next command. */);
10977
10978 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
10979 doc: /* Keymap that overrides all other local keymaps.
10980 If this variable is non-nil, it is used as a keymap instead of the
10981 buffer's local map, and the minor mode keymaps and text property keymaps. */);
10982 Voverriding_local_map = Qnil;
10983
10984 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag,
10985 doc: /* Non-nil means `overriding-local-map' applies to the menu bar.
10986 Otherwise, the menu bar continues to reflect the buffer's local map
10987 and the minor mode maps regardless of `overriding-local-map'. */);
10988 Voverriding_local_map_menu_flag = Qnil;
10989
10990 DEFVAR_LISP ("special-event-map", &Vspecial_event_map,
10991 doc: /* Keymap defining bindings for special events to execute at low level. */);
10992 Vspecial_event_map = Fcons (intern ("keymap"), Qnil);
10993
10994 DEFVAR_LISP ("track-mouse", &do_mouse_tracking,
10995 doc: /* *Non-nil means generate motion events for mouse motion. */);
10996
10997 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist,
10998 doc: /* Alist of system-specific X windows key symbols.
10999 Each element should have the form (N . SYMBOL) where N is the
11000 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11001 and SYMBOL is its name. */);
11002
11003 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list,
11004 doc: /* List of deferred actions to be performed at a later time.
11005 The precise format isn't relevant here; we just check whether it is nil. */);
11006 Vdeferred_action_list = Qnil;
11007
11008 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function,
11009 doc: /* Function to call to handle deferred actions, after each command.
11010 This function is called with no arguments after each command
11011 whenever `deferred-action-list' is non-nil. */);
11012 Vdeferred_action_function = Qnil;
11013
11014 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings,
11015 doc: /* *Non-nil means show the equivalent key-binding when M-x command has one.
11016 The value can be a length of time to show the message for.
11017 If the value is non-nil and not a number, we wait 2 seconds. */);
11018 Vsuggest_key_bindings = Qt;
11019
11020 DEFVAR_LISP ("timer-list", &Vtimer_list,
11021 doc: /* List of active absolute time timers in order of increasing time. */);
11022 Vtimer_list = Qnil;
11023
11024 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list,
11025 doc: /* List of active idle-time timers in order of increasing time. */);
11026 Vtimer_idle_list = Qnil;
11027
11028 DEFVAR_LISP ("input-method-function", &Vinput_method_function,
11029 doc: /* If non-nil, the function that implements the current input method.
11030 It's called with one argument, a printing character that was just read.
11031 \(That means a character with code 040...0176.)
11032 Typically this function uses `read-event' to read additional events.
11033 When it does so, it should first bind `input-method-function' to nil
11034 so it will not be called recursively.
11035
11036 The function should return a list of zero or more events
11037 to be used as input. If it wants to put back some events
11038 to be reconsidered, separately, by the input method,
11039 it can add them to the beginning of `unread-command-events'.
11040
11041 The input method function can find in `input-method-previous-method'
11042 the previous echo area message.
11043
11044 The input method function should refer to the variables
11045 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11046 for guidance on what to do. */);
11047 Vinput_method_function = Qnil;
11048
11049 DEFVAR_LISP ("input-method-previous-message",
11050 &Vinput_method_previous_message,
11051 doc: /* When `input-method-function' is called, hold the previous echo area message.
11052 This variable exists because `read-event' clears the echo area
11053 before running the input method. It is nil if there was no message. */);
11054 Vinput_method_previous_message = Qnil;
11055
11056 DEFVAR_LISP ("show-help-function", &Vshow_help_function,
11057 doc: /* If non-nil, the function that implements the display of help.
11058 It's called with one argument, the help string to display. */);
11059 Vshow_help_function = Qnil;
11060
11061 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment,
11062 doc: /* If non-nil, suppress point adjustment after executing a command.
11063
11064 After a command is executed, if point is moved into a region that has
11065 special properties (e.g. composition, display), we adjust point to
11066 the boundary of the region. But, several special commands sets this
11067 variable to non-nil, then we suppress the point adjustment.
11068
11069 This variable is set to nil before reading a command, and is checked
11070 just after executing the command. */);
11071 Vdisable_point_adjustment = Qnil;
11072
11073 DEFVAR_LISP ("global-disable-point-adjustment",
11074 &Vglobal_disable_point_adjustment,
11075 doc: /* *If non-nil, always suppress point adjustment.
11076
11077 The default value is nil, in which case, point adjustment are
11078 suppressed only after special commands that set
11079 `disable-point-adjustment' (which see) to non-nil. */);
11080 Vglobal_disable_point_adjustment = Qnil;
11081
11082 DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings,
11083 doc: /* Non-nil means updating menu bindings is allowed.
11084 A value of nil means menu bindings should not be updated.
11085 Used during Emacs' startup. */);
11086 update_menu_bindings = 1;
11087
11088 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout,
11089 doc: /* *How long to display an echo-area message when the minibuffer is active.
11090 If the value is not a number, such messages don't time out. */);
11091 Vminibuffer_message_timeout = make_number (2);
11092 }
11093
11094 void
11095 keys_of_keyboard ()
11096 {
11097 initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
11098 initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
11099 initial_define_key (meta_map, Ctl ('C'), "exit-recursive-edit");
11100 initial_define_key (global_map, Ctl (']'), "abort-recursive-edit");
11101 initial_define_key (meta_map, 'x', "execute-extended-command");
11102
11103 initial_define_lispy_key (Vspecial_event_map, "delete-frame",
11104 "handle-delete-frame");
11105 initial_define_lispy_key (Vspecial_event_map, "iconify-frame",
11106 "ignore-event");
11107 initial_define_lispy_key (Vspecial_event_map, "make-frame-visible",
11108 "ignore-event");
11109 initial_define_lispy_key (Vspecial_event_map, "select-window",
11110 "handle-select-window");
11111 initial_define_lispy_key (Vspecial_event_map, "save-session",
11112 "handle-save-session");
11113 }