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