(frame-notice-user-settings): Use geometry parms from frame
[bpt/emacs.git] / src / keyboard.c
CommitLineData
284f4730 1/* Keyboard and mouse input; editor command loop.
3a22ee35 2 Copyright (C) 1985,86,87,88,89,93,94 Free Software Foundation, Inc.
284f4730
JB
3
4This file is part of GNU Emacs.
5
6GNU Emacs is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
7b4aedb9 8the Free Software Foundation; either version 2, or (at your option)
284f4730
JB
9any later version.
10
11GNU Emacs is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Emacs; see the file COPYING. If not, write to
18the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20/* Allow config.h to undefine symbols found here. */
21#include <signal.h>
22
18160b98 23#include <config.h>
284f4730
JB
24#include <stdio.h>
25#undef NULL
26#include "termchar.h"
27#include "termopts.h"
28#include "lisp.h"
29#include "termhooks.h"
30#include "macros.h"
ff11dfa1 31#include "frame.h"
284f4730
JB
32#include "window.h"
33#include "commands.h"
34#include "buffer.h"
35#include "disptab.h"
f4255cd1 36#include "dispextern.h"
284f4730 37#include "keyboard.h"
497ba7a1 38#include "intervals.h"
9ac0d9e0 39#include "blockinput.h"
284f4730
JB
40#include <setjmp.h>
41#include <errno.h>
42
80e4aa30
RS
43#ifdef MSDOS
44#include "msdos.h"
45#include <time.h>
46#else /* not MSDOS */
284f4730
JB
47#ifndef VMS
48#include <sys/ioctl.h>
284f4730 49#endif
80e4aa30 50#endif /* not MSDOS */
284f4730 51
52baf19e 52#include "syssignal.h"
6ef5b54f 53#include "systty.h"
ffd56f97 54#include "systime.h"
52baf19e
JB
55
56extern int errno;
57
9ac0d9e0
JB
58/* Variables for blockinput.h: */
59
60/* Non-zero if interrupt input is blocked right now. */
63927c41 61int interrupt_input_blocked;
9ac0d9e0
JB
62
63/* Nonzero means an input interrupt has arrived
64 during the current critical section. */
63927c41 65int interrupt_input_pending;
9ac0d9e0
JB
66
67
284f4730
JB
68#ifdef HAVE_X_WINDOWS
69extern Lisp_Object Vmouse_grabbed;
70
71/* Make all keyboard buffers much bigger when using X windows. */
72#define KBD_BUFFER_SIZE 4096
73#else /* No X-windows, character input */
74#define KBD_BUFFER_SIZE 256
75#endif /* No X-windows */
76
77/* Following definition copied from eval.c */
78
79struct backtrace
80 {
81 struct backtrace *next;
82 Lisp_Object *function;
83 Lisp_Object *args; /* Points to vector of args. */
84 int nargs; /* length of vector. If nargs is UNEVALLED,
85 args points to slot holding list of
86 unevalled args */
87 char evalargs;
88 };
89
90/* Non-nil disable property on a command means
91 do not execute it; call disabled-command-hook's value instead. */
2e894dab 92Lisp_Object Qdisabled, Qdisabled_command_hook;
284f4730
JB
93
94#define NUM_RECENT_KEYS (100)
95int recent_keys_index; /* Index for storing next element into recent_keys */
96int total_keys; /* Total number of elements stored into recent_keys */
5160df46 97Lisp_Object recent_keys; /* A vector, holding the last 100 keystrokes */
284f4730 98
6569cc8d
JB
99/* Vector holding the key sequence that invoked the current command.
100 It is reused for each command, and it may be longer than the current
101 sequence; this_command_key_count indicates how many elements
102 actually mean something.
103 It's easier to staticpro a single Lisp_Object than an array. */
104Lisp_Object this_command_keys;
105int this_command_key_count;
284f4730
JB
106
107extern int minbuf_level;
108
109extern struct backtrace *backtrace_list;
110
111/* Nonzero means do menu prompting. */
112static int menu_prompting;
113
114/* Character to see next line of menu prompt. */
115static Lisp_Object menu_prompt_more_char;
116
117/* For longjmp to where kbd input is being done. */
118static jmp_buf getcjmp;
119
120/* True while doing kbd input. */
121int waiting_for_input;
122
123/* True while displaying for echoing. Delays C-g throwing. */
124static int echoing;
125
80e4aa30 126/* Nonzero means C-g should cause immediate error-signal. */
284f4730
JB
127int immediate_quit;
128
129/* Character to recognize as the help char. */
7e85b935 130Lisp_Object Vhelp_char;
284f4730
JB
131
132/* Form to execute when help char is typed. */
133Lisp_Object Vhelp_form;
134
7e85b935
RS
135/* Command to run when the help character follows a prefix key. */
136Lisp_Object Vprefix_help_command;
137
9f9c0e27
RS
138/* List of items that should move to the end of the menu bar. */
139Lisp_Object Vmenu_bar_final_items;
a73c5e29 140
284f4730
JB
141/* Character that causes a quit. Normally C-g.
142
143 If we are running on an ordinary terminal, this must be an ordinary
144 ASCII char, since we want to make it our interrupt character.
145
146 If we are not running on an ordinary terminal, it still needs to be
147 an ordinary ASCII char. This character needs to be recognized in
148 the input interrupt handler. At this point, the keystroke is
149 represented as a struct input_event, while the desired quit
150 character is specified as a lispy event. The mapping from struct
151 input_events to lispy events cannot run in an interrupt handler,
152 and the reverse mapping is difficult for anything but ASCII
153 keystrokes.
154
155 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
156 ASCII character. */
157int quit_char;
158
159extern Lisp_Object current_global_map;
160extern int minibuf_level;
161
9dd3131c
RS
162/* If non-nil, this is a map that overrides all other local maps. */
163Lisp_Object Voverriding_local_map;
164
284f4730
JB
165/* Current depth in recursive edits. */
166int command_loop_level;
167
168/* Total number of times command_loop has read a key sequence. */
169int num_input_keys;
170
171/* Last input character read as a command. */
172Lisp_Object last_command_char;
173
7d6de002
RS
174/* Last input character read as a command, not counting menus
175 reached by the mouse. */
176Lisp_Object last_nonmenu_event;
177
284f4730
JB
178/* Last input character read for any purpose. */
179Lisp_Object last_input_char;
180
dbc4e1c1 181/* If not Qnil, a list of objects to be read as subsequent command input. */
24597608 182Lisp_Object Vunread_command_events;
284f4730 183
86e5706b
RS
184/* If not -1, an event to be read as subsequent command input. */
185int unread_command_char;
186
cd21b839
JB
187/* If not Qnil, this is a switch-frame event which we decided to put
188 off until the end of a key sequence. This should be read as the
dbc4e1c1 189 next command input, after any unread_command_events.
8f805655
JB
190
191 read_key_sequence uses this to delay switch-frame events until the
192 end of the key sequence; Fread_char uses it to put off switch-frame
193 events until a non-ASCII event is acceptable as input. */
194Lisp_Object unread_switch_frame;
cd21b839 195
9fa4395d
RS
196/* A mask of extra modifier bits to put into every keyboard char. */
197int extra_keyboard_modifiers;
198
284f4730
JB
199/* Char to use as prefix when a meta character is typed in.
200 This is bound on entry to minibuffer in case ESC is changed there. */
201
202Lisp_Object meta_prefix_char;
203
204/* Last size recorded for a current buffer which is not a minibuffer. */
205static int last_non_minibuf_size;
206
06ef7355 207/* Number of idle seconds before an auto-save and garbage collection. */
284f4730
JB
208static Lisp_Object Vauto_save_timeout;
209
210/* Total number of times read_char has returned. */
211int num_input_chars;
212
51172b6d
RS
213/* Total number of times read_char has returned, outside of macros. */
214int num_nonmacro_input_chars;
215
284f4730
JB
216/* Auto-save automatically when this many characters have been typed
217 since the last time. */
218
219static int auto_save_interval;
220
51172b6d 221/* Value of num_nonmacro_input_chars as of last auto save. */
284f4730
JB
222
223int last_auto_save;
224
225/* Last command executed by the editor command loop, not counting
226 commands that set the prefix argument. */
227
228Lisp_Object last_command;
229
230/* The command being executed by the command loop.
231 Commands may set this, and the value set will be copied into last_command
232 instead of the actual command. */
233Lisp_Object this_command;
234
b453f72e
KH
235/* The value of point when the last command was executed. */
236int last_point_position;
237
07d2b8de 238#ifdef MULTI_FRAME
fce33686 239/* The frame in which the last input event occurred, or Qmacro if the
3c370943
JB
240 last event came from a macro. We use this to determine when to
241 generate switch-frame events. This may be cleared by functions
242 like Fselect_frame, to make sure that a switch-frame event is
243 generated by the next character. */
244Lisp_Object internal_last_event_frame;
a974bea1 245#endif
3c370943
JB
246
247/* A user-visible version of the above, intended to allow users to
248 figure out where the last event came from, if the event doesn't
249 carry that information itself (i.e. if it was a character). */
ff11dfa1 250Lisp_Object Vlast_event_frame;
284f4730 251
1113d9db
JB
252/* The timestamp of the last input event we received from the X server.
253 X Windows wants this for selection ownership. */
284f4730
JB
254unsigned long last_event_timestamp;
255
256Lisp_Object Qself_insert_command;
257Lisp_Object Qforward_char;
258Lisp_Object Qbackward_char;
e58aa385 259Lisp_Object Qundefined;
284f4730
JB
260
261/* read_key_sequence stores here the command definition of the
262 key sequence that it reads. */
263Lisp_Object read_key_sequence_cmd;
264
265/* Form to evaluate (if non-nil) when Emacs is started. */
266Lisp_Object Vtop_level;
267
268/* User-supplied string to translate input characters through. */
269Lisp_Object Vkeyboard_translate_table;
270
271/* Keymap mapping ASCII function key sequences onto their preferred forms. */
272extern Lisp_Object Vfunction_key_map;
273
a612e298
RS
274/* Keymap mapping ASCII function key sequences onto their preferred forms. */
275Lisp_Object Vkey_translation_map;
276
86e5706b
RS
277/* Non-nil means deactivate the mark at end of this command. */
278Lisp_Object Vdeactivate_mark;
279
48e416d4
RS
280/* Menu bar specified in Lucid Emacs fashion. */
281
282Lisp_Object Vlucid_menu_bar_dirty_flag;
283Lisp_Object Qrecompute_lucid_menubar, Qactivate_menubar_hook;
284
86e5706b
RS
285/* Hooks to run before and after each command. */
286Lisp_Object Qpre_command_hook, Qpost_command_hook;
287Lisp_Object Vpre_command_hook, Vpost_command_hook;
40932d1a 288Lisp_Object Qcommand_hook_internal, Vcommand_hook_internal;
86e5706b 289
284f4730
JB
290/* File in which we write all commands we read. */
291FILE *dribble;
292
293/* Nonzero if input is available. */
294int input_pending;
295
b04904fb
RS
296/* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
297 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
298
284f4730
JB
299int meta_key;
300
301extern char *pending_malloc_warning;
302
303/* Circular buffer for pre-read keyboard input. */
304static struct input_event kbd_buffer[KBD_BUFFER_SIZE];
305
7b4aedb9 306/* Vector to GCPRO the frames and windows mentioned in kbd_buffer.
4bb994d1 307
7b4aedb9
JB
308 The interrupt-level event handlers will never enqueue an event on a
309 frame which is not in Vframe_list, and once an event is dequeued,
3c370943
JB
310 internal_last_event_frame or the event itself points to the frame.
311 So that's all fine.
4bb994d1
JB
312
313 But while the event is sitting in the queue, it's completely
314 unprotected. Suppose the user types one command which will run for
315 a while and then delete a frame, and then types another event at
316 the frame that will be deleted, before the command gets around to
317 it. Suppose there are no references to this frame elsewhere in
318 Emacs, and a GC occurs before the second event is dequeued. Now we
319 have an event referring to a freed frame, which will crash Emacs
320 when it is dequeued.
321
3c370943 322 Similar things happen when an event on a scroll bar is enqueued; the
7b4aedb9 323 window may be deleted while the event is in the queue.
4bb994d1 324
7b4aedb9
JB
325 So, we use this vector to protect the frame_or_window field in the
326 event queue. That way, they'll be dequeued as dead frames or
327 windows, but still valid lisp objects.
328
329 If kbd_buffer[i].kind != no_event, then
330 (XVECTOR (kbd_buffer_frame_or_window)->contents[i]
331 == kbd_buffer[i].frame_or_window. */
332static Lisp_Object kbd_buffer_frame_or_window;
4bb994d1 333
284f4730
JB
334/* Pointer to next available character in kbd_buffer.
335 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
336 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the the
337 next available char is in kbd_buffer[0]. */
338static struct input_event *kbd_fetch_ptr;
339
340/* Pointer to next place to store character in kbd_buffer. This
341 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
342 character should go in kbd_buffer[0]. */
ff0b5f4c
JB
343#ifdef __STDC__
344volatile
345#endif
284f4730
JB
346static struct input_event *kbd_store_ptr;
347
348/* The above pair of variables forms a "queue empty" flag. When we
349 enqueue a non-hook event, we increment kbd_write_count. When we
350 dequeue a non-hook event, we increment kbd_read_count. We say that
4bb994d1 351 there is input available iff the two counters are not equal.
284f4730
JB
352
353 Why not just have a flag set and cleared by the enqueuing and
354 dequeuing functions? Such a flag could be screwed up by interrupts
355 at inopportune times. */
356
663258f2 357/* If this flag is non-zero, we check mouse_moved to see when the
4bb994d1 358 mouse moves, and motion events will appear in the input stream. If
663258f2
JB
359 it is zero, mouse motion is ignored. */
360static int do_mouse_tracking;
284f4730
JB
361
362/* The window system handling code should set this if the mouse has
363 moved since the last call to the mouse_position_hook. Calling that
364 hook should clear this. Code assumes that if this is set, it can
365 call mouse_position_hook to get the promised position, so don't set
366 it unless you're prepared to substantiate the claim! */
367int mouse_moved;
368
369/* True iff there is an event in kbd_buffer, or if mouse tracking is
370 enabled and there is a new mouse position in the mouse movement
371 buffer. Note that if this is false, that doesn't mean that there
372 is readable input; all the events in the queue might be button-up
373 events, and do_mouse_tracking might be off. */
374#define EVENT_QUEUES_EMPTY \
375 ((kbd_fetch_ptr == kbd_store_ptr) && (!do_mouse_tracking || !mouse_moved))
376
377
378/* Symbols to head events. */
379Lisp_Object Qmouse_movement;
3c370943 380Lisp_Object Qscroll_bar_movement;
cd21b839
JB
381Lisp_Object Qswitch_frame;
382
284f4730
JB
383/* Symbols to denote kinds of events. */
384Lisp_Object Qfunction_key;
385Lisp_Object Qmouse_click;
386/* Lisp_Object Qmouse_movement; - also an event header */
284f4730
JB
387
388/* Properties of event headers. */
389Lisp_Object Qevent_kind;
88cb0656 390Lisp_Object Qevent_symbol_elements;
284f4730 391
598a9fa7
JB
392Lisp_Object Qmenu_enable;
393
0a7f1fc0
JB
394/* An event header symbol HEAD may have a property named
395 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
396 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
397 mask of modifiers applied to it. If present, this is used to help
398 speed up parse_modifiers. */
399Lisp_Object Qevent_symbol_element_mask;
400
401/* An unmodified event header BASE may have a property named
402 Qmodifier_cache, which is an alist mapping modifier masks onto
403 modified versions of BASE. If present, this helps speed up
404 apply_modifiers. */
405Lisp_Object Qmodifier_cache;
406
5ec75a55 407/* Symbols to use for parts of windows. */
284f4730 408Lisp_Object Qmode_line;
e5d77022 409Lisp_Object Qvertical_line;
3c370943 410Lisp_Object Qvertical_scroll_bar;
5ec75a55
RS
411Lisp_Object Qmenu_bar;
412
413extern Lisp_Object Qmenu_enable;
284f4730 414
f4255cd1
JB
415Lisp_Object recursive_edit_unwind (), command_loop ();
416Lisp_Object Fthis_command_keys ();
03b4122a 417Lisp_Object Qextended_command_history;
284f4730 418
ffd56f97
JB
419/* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
420 happens. */
421EMACS_TIME *input_available_clear_time;
284f4730
JB
422
423/* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
424 Default is 1 if INTERRUPT_INPUT is defined. */
425int interrupt_input;
426
427/* Nonzero while interrupts are temporarily deferred during redisplay. */
428int interrupts_deferred;
429
430/* nonzero means use ^S/^Q for flow control. */
431int flow_control;
432
284f4730
JB
433/* Allow m- file to inhibit use of FIONREAD. */
434#ifdef BROKEN_FIONREAD
435#undef FIONREAD
436#endif
437
438/* We are unable to use interrupts if FIONREAD is not available,
439 so flush SIGIO so we won't try. */
440#ifndef FIONREAD
441#ifdef SIGIO
442#undef SIGIO
443#endif
444#endif
445
34f04431
RS
446/* If we support X Windows, turn on the code to poll periodically
447 to detect C-g. It isn't actually used when doing interrupt input. */
284f4730 448#ifdef HAVE_X_WINDOWS
284f4730
JB
449#define POLL_FOR_INPUT
450#endif
284f4730
JB
451\f
452/* Global variable declarations. */
453
454/* Function for init_keyboard to call with no args (if nonzero). */
455void (*keyboard_init_hook) ();
456
457static int read_avail_input ();
458static void get_input_pending ();
9fd7d808 459static int readable_events ();
8150596a
RS
460static Lisp_Object read_char_x_menu_prompt ();
461static Lisp_Object read_char_minibuf_menu_prompt ();
a612e298
RS
462static Lisp_Object make_lispy_event ();
463static Lisp_Object make_lispy_movement ();
464static Lisp_Object modify_event_symbol ();
465static Lisp_Object make_lispy_switch_frame ();
284f4730
JB
466
467/* > 0 if we are to echo keystrokes. */
468static int echo_keystrokes;
469
470/* Nonzero means echo each character as typed. */
471static int immediate_echo;
472
473/* The text we're echoing in the modeline - partial key sequences,
f4255cd1
JB
474 usually. '\0'-terminated. This really shouldn't have a fixed size. */
475static char echobuf[300];
284f4730
JB
476
477/* Where to append more text to echobuf if we want to. */
478static char *echoptr;
479
8026024c
KH
480/* Nonzero means don't try to suspend even if the operating system seems
481 to support it. */
482static int cannot_suspend;
483
284f4730
JB
484#define min(a,b) ((a)<(b)?(a):(b))
485#define max(a,b) ((a)>(b)?(a):(b))
486
487/* Install the string STR as the beginning of the string of echoing,
488 so that it serves as a prompt for the next character.
489 Also start echoing. */
490
491echo_prompt (str)
492 char *str;
493{
494 int len = strlen (str);
495 if (len > sizeof echobuf - 4)
496 len = sizeof echobuf - 4;
0a7f1fc0 497 bcopy (str, echobuf, len);
284f4730 498 echoptr = echobuf + len;
0a7f1fc0 499 *echoptr = '\0';
284f4730
JB
500
501 echo ();
502}
503
504/* Add C to the echo string, if echoing is going on.
505 C can be a character, which is printed prettily ("M-C-x" and all that
506 jazz), or a symbol, whose name is printed. */
507
508echo_char (c)
509 Lisp_Object c;
510{
511 extern char *push_key_description ();
512
513 if (immediate_echo)
514 {
515 char *ptr = echoptr;
516
517 if (ptr != echobuf)
518 *ptr++ = ' ';
519
520 /* If someone has passed us a composite event, use its head symbol. */
88cb0656 521 c = EVENT_HEAD (c);
284f4730
JB
522
523 if (XTYPE (c) == Lisp_Int)
524 {
525 if (ptr - echobuf > sizeof echobuf - 6)
526 return;
527
cb5df6ae 528 ptr = push_key_description (XINT (c), ptr);
284f4730
JB
529 }
530 else if (XTYPE (c) == Lisp_Symbol)
531 {
532 struct Lisp_String *name = XSYMBOL (c)->name;
533 if (((ptr - echobuf) + name->size + 4) > sizeof echobuf)
534 return;
535 bcopy (name->data, ptr, name->size);
536 ptr += name->size;
537 }
538
7e85b935 539 if (echoptr == echobuf && EQ (c, Vhelp_char))
284f4730
JB
540 {
541 strcpy (ptr, " (Type ? for further options)");
542 ptr += strlen (ptr);
543 }
544
545 *ptr = 0;
546 echoptr = ptr;
547
548 echo ();
549 }
550}
551
552/* Temporarily add a dash to the end of the echo string if it's not
553 empty, so that it serves as a mini-prompt for the very next character. */
554
555echo_dash ()
556{
557 if (!immediate_echo && echoptr == echobuf)
558 return;
4bafa972
JB
559 /* Do nothing if not echoing at all. */
560 if (echoptr == 0)
561 return;
284f4730
JB
562
563 /* Put a dash at the end of the buffer temporarily,
564 but make it go away when the next character is added. */
565 echoptr[0] = '-';
566 echoptr[1] = 0;
567
568 echo ();
569}
570
571/* Display the current echo string, and begin echoing if not already
572 doing so. */
573
574echo ()
575{
576 if (!immediate_echo)
577 {
578 int i;
579 immediate_echo = 1;
580
581 for (i = 0; i < this_command_key_count; i++)
6569cc8d 582 echo_char (XVECTOR (this_command_keys)->contents[i]);
284f4730
JB
583 echo_dash ();
584 }
585
586 echoing = 1;
587 message1 (echobuf);
588 echoing = 0;
589
590 if (waiting_for_input && !NILP (Vquit_flag))
591 quit_throw_to_read_char ();
592}
593
594/* Turn off echoing, for the start of a new command. */
595
596cancel_echoing ()
597{
598 immediate_echo = 0;
599 echoptr = echobuf;
600}
601
602/* Return the length of the current echo string. */
603
604static int
605echo_length ()
606{
607 return echoptr - echobuf;
608}
609
610/* Truncate the current echo message to its first LEN chars.
611 This and echo_char get used by read_key_sequence when the user
ff11dfa1 612 switches frames while entering a key sequence. */
284f4730
JB
613
614static void
615echo_truncate (len)
616 int len;
617{
618 echobuf[len] = '\0';
0a7f1fc0 619 echoptr = echobuf + len;
40932d1a 620 truncate_echo_area (len);
284f4730
JB
621}
622
623\f
624/* Functions for manipulating this_command_keys. */
625static void
626add_command_key (key)
627 Lisp_Object key;
628{
6569cc8d
JB
629 int size = XVECTOR (this_command_keys)->size;
630
631 if (this_command_key_count >= size)
284f4730 632 {
9b8eb840 633 Lisp_Object new_keys;
6569cc8d 634
9b8eb840 635 new_keys = Fmake_vector (make_number (size * 2), Qnil);
6569cc8d
JB
636 bcopy (XVECTOR (this_command_keys)->contents,
637 XVECTOR (new_keys)->contents,
8f805655 638 size * sizeof (Lisp_Object));
6569cc8d
JB
639
640 this_command_keys = new_keys;
284f4730 641 }
6569cc8d
JB
642
643 XVECTOR (this_command_keys)->contents[this_command_key_count++] = key;
284f4730
JB
644}
645\f
646Lisp_Object
647recursive_edit_1 ()
648{
649 int count = specpdl_ptr - specpdl;
650 Lisp_Object val;
651
652 if (command_loop_level > 0)
653 {
654 specbind (Qstandard_output, Qt);
655 specbind (Qstandard_input, Qt);
656 }
657
658 val = command_loop ();
659 if (EQ (val, Qt))
660 Fsignal (Qquit, Qnil);
661
cb5df6ae 662 return unbind_to (count, Qnil);
284f4730
JB
663}
664
665/* When an auto-save happens, record the "time", and don't do again soon. */
5846638c 666
284f4730
JB
667record_auto_save ()
668{
51172b6d 669 last_auto_save = num_nonmacro_input_chars;
284f4730 670}
5846638c
RS
671
672/* Make an auto save happen as soon as possible at command level. */
673
674force_auto_save_soon ()
675{
676 last_auto_save = - auto_save_interval - 1;
241ceaf7
RS
677
678 record_asynch_buffer_change ();
5846638c 679}
284f4730 680\f
284f4730
JB
681DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
682 "Invoke the editor command loop recursively.\n\
683To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
684that tells this function to return.\n\
685Alternately, `(throw 'exit t)' makes this function signal an error.\n\
686This function is called by the editor initialization to begin editing.")
687 ()
688{
689 int count = specpdl_ptr - specpdl;
690 Lisp_Object val;
691
692 command_loop_level++;
693 update_mode_lines = 1;
694
695 record_unwind_protect (recursive_edit_unwind,
696 (command_loop_level
697 && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
698 ? Fcurrent_buffer ()
699 : Qnil);
700 recursive_edit_1 ();
701 return unbind_to (count, Qnil);
702}
703
704Lisp_Object
705recursive_edit_unwind (buffer)
706 Lisp_Object buffer;
707{
708 if (!NILP (buffer))
709 Fset_buffer (buffer);
710
711 command_loop_level--;
712 update_mode_lines = 1;
713 return Qnil;
714}
715\f
716Lisp_Object
717cmd_error (data)
718 Lisp_Object data;
719{
720 Lisp_Object errmsg, tail, errname, file_error;
721 Lisp_Object stream;
722 struct gcpro gcpro1;
723 int i;
724
725 Vquit_flag = Qnil;
726 Vinhibit_quit = Qt;
727 Vstandard_output = Qt;
728 Vstandard_input = Qt;
729 Vexecuting_macro = Qnil;
730 echo_area_glyphs = 0;
731
ff11dfa1 732 /* If the window system or terminal frame hasn't been initialized
284f4730
JB
733 yet, or we're not interactive, it's best to dump this message out
734 to stderr and exit. */
ff11dfa1 735 if (! FRAME_MESSAGE_BUF (selected_frame)
284f4730
JB
736 || noninteractive)
737 stream = Qexternal_debugging_output;
738 else
739 {
740 Fdiscard_input ();
741 bitch_at_user ();
742 stream = Qt;
743 }
744
745 errname = Fcar (data);
746
747 if (EQ (errname, Qerror))
748 {
749 data = Fcdr (data);
750 if (!CONSP (data)) data = Qnil;
751 errmsg = Fcar (data);
752 file_error = Qnil;
753 }
754 else
755 {
756 errmsg = Fget (errname, Qerror_message);
757 file_error = Fmemq (Qfile_error,
758 Fget (errname, Qerror_conditions));
759 }
760
761 /* Print an error message including the data items.
762 This is done by printing it into a scratch buffer
763 and then making a copy of the text in the buffer. */
764
765 if (!CONSP (data)) data = Qnil;
766 tail = Fcdr (data);
767 GCPRO1 (tail);
768
769 /* For file-error, make error message by concatenating
770 all the data items. They are all strings. */
771 if (!NILP (file_error) && !NILP (tail))
772 errmsg = XCONS (tail)->car, tail = XCONS (tail)->cdr;
773
774 if (XTYPE (errmsg) == Lisp_String)
775 Fprinc (errmsg, stream);
776 else
777 write_string_1 ("peculiar error", -1, stream);
778
779 for (i = 0; CONSP (tail); tail = Fcdr (tail), i++)
780 {
781 write_string_1 (i ? ", " : ": ", 2, stream);
782 if (!NILP (file_error))
783 Fprinc (Fcar (tail), stream);
784 else
785 Fprin1 (Fcar (tail), stream);
786 }
787 UNGCPRO;
788
ff11dfa1 789 /* If the window system or terminal frame hasn't been initialized
284f4730 790 yet, or we're in -batch mode, this error should cause Emacs to exit. */
ff11dfa1 791 if (! FRAME_MESSAGE_BUF (selected_frame)
284f4730
JB
792 || noninteractive)
793 {
794 Fterpri (stream);
795 Fkill_emacs (make_number (-1));
796 }
797
798 Vquit_flag = Qnil;
799
800 Vinhibit_quit = Qnil;
801 return make_number (0);
802}
803\f
804Lisp_Object command_loop_1 ();
805Lisp_Object command_loop_2 ();
806Lisp_Object top_level_1 ();
807
808/* Entry to editor-command-loop.
809 This level has the catches for exiting/returning to editor command loop.
810 It returns nil to exit recursive edit, t to abort it. */
811
812Lisp_Object
813command_loop ()
814{
815 if (command_loop_level > 0 || minibuf_level > 0)
816 {
817 return internal_catch (Qexit, command_loop_2, Qnil);
818 }
819 else
820 while (1)
821 {
822 internal_catch (Qtop_level, top_level_1, Qnil);
823 internal_catch (Qtop_level, command_loop_2, Qnil);
824
825 /* End of file in -batch run causes exit here. */
826 if (noninteractive)
827 Fkill_emacs (Qt);
828 }
829}
830
831/* Here we catch errors in execution of commands within the
832 editing loop, and reenter the editing loop.
833 When there is an error, cmd_error runs and returns a non-nil
834 value to us. A value of nil means that cmd_loop_1 itself
835 returned due to end of file (or end of kbd macro). */
836
837Lisp_Object
838command_loop_2 ()
839{
840 register Lisp_Object val;
841
842 do
843 val = internal_condition_case (command_loop_1, Qerror, cmd_error);
844 while (!NILP (val));
845
846 return Qnil;
847}
848
849Lisp_Object
850top_level_2 ()
851{
852 return Feval (Vtop_level);
853}
854
855Lisp_Object
856top_level_1 ()
857{
858 /* On entry to the outer level, run the startup file */
859 if (!NILP (Vtop_level))
860 internal_condition_case (top_level_2, Qerror, cmd_error);
861 else if (!NILP (Vpurify_flag))
862 message ("Bare impure Emacs (standard Lisp code not loaded)");
863 else
864 message ("Bare Emacs (standard Lisp code not loaded)");
865 return Qnil;
866}
867
868DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
869 "Exit all recursive editing levels.")
870 ()
871{
872 Fthrow (Qtop_level, Qnil);
873}
874
875DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
876 "Exit from the innermost recursive edit or minibuffer.")
877 ()
878{
879 if (command_loop_level > 0 || minibuf_level > 0)
880 Fthrow (Qexit, Qnil);
881
882 error ("No recursive edit is in progress");
883}
884
885DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
886 "Abort the command that requested this recursive edit or minibuffer input.")
887 ()
888{
889 if (command_loop_level > 0 || minibuf_level > 0)
890 Fthrow (Qexit, Qt);
891
892 error ("No recursive edit is in progress");
893}
894\f
895/* This is the actual command reading loop,
896 sans error-handling encapsulation. */
897
898Lisp_Object Fcommand_execute ();
899static int read_key_sequence ();
900
901Lisp_Object
902command_loop_1 ()
903{
48e416d4 904 Lisp_Object cmd, tem;
284f4730
JB
905 int lose;
906 int nonundocount;
907 Lisp_Object keybuf[30];
908 int i;
909 int no_redisplay;
910 int no_direct;
86e5706b
RS
911 int prev_modiff;
912 struct buffer *prev_buffer;
284f4730
JB
913
914 Vprefix_arg = Qnil;
86e5706b 915 Vdeactivate_mark = Qnil;
284f4730
JB
916 waiting_for_input = 0;
917 cancel_echoing ();
918
284f4730
JB
919 nonundocount = 0;
920 no_redisplay = 0;
921 this_command_key_count = 0;
922
a612e298
RS
923 /* Make sure this hook runs after commands that get errors and
924 throw to top level. */
88ce066e 925 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
bb62bd91 926 {
bb62bd91
RS
927 /* If we get an error during the post-command-hook,
928 cause post-command-hook to be nil. */
40932d1a 929 Vcommand_hook_internal = Vpost_command_hook;
bb62bd91
RS
930 Vpost_command_hook = Qnil;
931
40932d1a 932 call1 (Vrun_hooks, Qcommand_hook_internal);
bb62bd91 933
40932d1a 934 Vpost_command_hook = Vcommand_hook_internal;
bb62bd91 935 }
a612e298 936
51d5a2c9
RS
937 /* Do this after running Vpost_command_hook, for consistency. */
938 last_command = this_command;
939
284f4730
JB
940 while (1)
941 {
942 /* Install chars successfully executed in kbd macro. */
943
944 if (defining_kbd_macro && NILP (Vprefix_arg))
945 finalize_kbd_macro_chars ();
946
947 /* Make sure the current window's buffer is selected. */
948 if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
949 set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
950
951 /* Display any malloc warning that just came out. Use while because
952 displaying one warning can cause another. */
953
954 while (pending_malloc_warning)
955 display_malloc_warning ();
956
957 no_direct = 0;
958
86e5706b
RS
959 Vdeactivate_mark = Qnil;
960
284f4730 961 /* If minibuffer on and echo area in use,
eb8c3be9 962 wait 2 sec and redraw minibuffer. */
284f4730
JB
963
964 if (minibuf_level && echo_area_glyphs)
965 {
f1bed6d8
RS
966 /* Bind inhibit-quit to t so that C-g gets read in
967 rather than quitting back to the minibuffer. */
968 int count = specpdl_ptr - specpdl;
969 specbind (Qinhibit_quit, Qt);
284f4730 970 Fsit_for (make_number (2), Qnil, Qnil);
cb5df6ae 971 unbind_to (count, Qnil);
f1bed6d8 972
284f4730
JB
973 echo_area_glyphs = 0;
974 no_direct = 1;
975 if (!NILP (Vquit_flag))
976 {
977 Vquit_flag = Qnil;
24597608 978 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
284f4730
JB
979 }
980 }
981
982#ifdef C_ALLOCA
983 alloca (0); /* Cause a garbage collection now */
984 /* Since we can free the most stuff here. */
985#endif /* C_ALLOCA */
986
8f805655 987#if 0
ff11dfa1 988#ifdef MULTI_FRAME
8f805655
JB
989 /* Select the frame that the last event came from. Usually,
990 switch-frame events will take care of this, but if some lisp
991 code swallows a switch-frame event, we'll fix things up here.
992 Is this a good idea? */
3c370943
JB
993 if (XTYPE (internal_last_event_frame) == Lisp_Frame
994 && XFRAME (internal_last_event_frame) != selected_frame)
995 Fselect_frame (internal_last_event_frame, Qnil);
cd21b839 996#endif
284f4730 997#endif
48e416d4
RS
998 /* If it has changed current-menubar from previous value,
999 really recompute the menubar from the value. */
a646e520
RS
1000 if (! NILP (Vlucid_menu_bar_dirty_flag)
1001 && !NILP (Ffboundp (Qrecompute_lucid_menubar)))
48e416d4
RS
1002 call0 (Qrecompute_lucid_menubar);
1003
8f805655 1004 /* Read next key sequence; i gets its length. */
84d91fda 1005 i = read_key_sequence (keybuf, (sizeof keybuf / sizeof (keybuf[0])), Qnil);
8f805655
JB
1006
1007 ++num_input_keys;
1008
284f4730
JB
1009 /* Now we have read a key sequence of length I,
1010 or else I is 0 and we found end of file. */
1011
1012 if (i == 0) /* End of file -- happens only in */
1013 return Qnil; /* a kbd macro, at the end. */
dcc408a0
RS
1014 /* -1 means read_key_sequence got a menu that was rejected.
1015 Just loop around and read another command. */
1016 if (i == -1)
1017 {
1018 cancel_echoing ();
1019 this_command_key_count = 0;
1020 continue;
1021 }
284f4730 1022
284f4730
JB
1023 last_command_char = keybuf[i - 1];
1024
75c0b143
RS
1025 /* If the previous command tried to force a specific window-start,
1026 forget about that, in case this command moves point far away
1027 from that position. */
1028 XWINDOW (selected_window)->force_start = Qnil;
1029
284f4730
JB
1030 cmd = read_key_sequence_cmd;
1031 if (!NILP (Vexecuting_macro))
1032 {
1033 if (!NILP (Vquit_flag))
1034 {
1035 Vexecuting_macro = Qt;
1036 QUIT; /* Make some noise. */
1037 /* Will return since macro now empty. */
1038 }
1039 }
1040
1041 /* Do redisplay processing after this command except in special
40932d1a
RS
1042 cases identified below that set no_redisplay to 1.
1043 (actually, there's currently no way to prevent the redisplay,
1044 and no_redisplay is ignored.
1045 Perhaps someday we will really implement it. */
284f4730
JB
1046 no_redisplay = 0;
1047
86e5706b
RS
1048 prev_buffer = current_buffer;
1049 prev_modiff = MODIFF;
8746da95 1050 last_point_position = PT;
86e5706b 1051
284f4730
JB
1052 /* Execute the command. */
1053
86e5706b 1054 this_command = cmd;
88ce066e 1055 if (!NILP (Vpre_command_hook) && !NILP (Vrun_hooks))
bb62bd91 1056 {
bb62bd91
RS
1057 /* If we get an error during the pre-command-hook,
1058 cause pre-command-hook to be nil. */
40932d1a 1059 Vcommand_hook_internal = Vpre_command_hook;
bb62bd91
RS
1060 Vpre_command_hook = Qnil;
1061
40932d1a 1062 call1 (Vrun_hooks, Qcommand_hook_internal);
bb62bd91 1063
40932d1a 1064 Vpre_command_hook = Vcommand_hook_internal;
bb62bd91 1065 }
86e5706b 1066
258bf746 1067 if (NILP (this_command))
284f4730
JB
1068 {
1069 /* nil means key is undefined. */
1070 bitch_at_user ();
1071 defining_kbd_macro = 0;
1072 update_mode_lines = 1;
1073 Vprefix_arg = Qnil;
86e5706b 1074
284f4730
JB
1075 }
1076 else
1077 {
284f4730
JB
1078 if (NILP (Vprefix_arg) && ! no_direct)
1079 {
1080 /* Recognize some common commands in common situations and
1081 do them directly. */
258bf746 1082 if (EQ (this_command, Qforward_char) && point < ZV)
284f4730
JB
1083 {
1084 struct Lisp_Vector *dp
1085 = window_display_table (XWINDOW (selected_window));
1086 lose = FETCH_CHAR (point);
1087 SET_PT (point + 1);
0f7a8fee 1088 if ((dp
82ba47d7 1089 ? (VECTORP (DISP_CHAR_VECTOR (dp, lose))
06ddfb24 1090 && XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1)
0f7a8fee 1091 : (lose >= 0x20 && lose < 0x7f))
284f4730
JB
1092 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1093 >= MODIFF)
1094 && (XFASTINT (XWINDOW (selected_window)->last_point)
1095 == point - 1)
1096 && !windows_or_buffers_changed
1097 && EQ (current_buffer->selective_display, Qnil)
1098 && !detect_input_pending ()
1099 && NILP (Vexecuting_macro))
1100 no_redisplay = direct_output_forward_char (1);
1101 goto directly_done;
1102 }
258bf746 1103 else if (EQ (this_command, Qbackward_char) && point > BEGV)
284f4730
JB
1104 {
1105 struct Lisp_Vector *dp
1106 = window_display_table (XWINDOW (selected_window));
1107 SET_PT (point - 1);
1108 lose = FETCH_CHAR (point);
0f7a8fee
JB
1109 if ((dp
1110 ? (XTYPE (DISP_CHAR_VECTOR (dp, lose)) != Lisp_Vector
06ddfb24 1111 && XVECTOR (DISP_CHAR_VECTOR (dp, lose))->size == 1)
0f7a8fee 1112 : (lose >= 0x20 && lose < 0x7f))
284f4730
JB
1113 && (XFASTINT (XWINDOW (selected_window)->last_modified)
1114 >= MODIFF)
1115 && (XFASTINT (XWINDOW (selected_window)->last_point)
1116 == point + 1)
1117 && !windows_or_buffers_changed
1118 && EQ (current_buffer->selective_display, Qnil)
1119 && !detect_input_pending ()
1120 && NILP (Vexecuting_macro))
1121 no_redisplay = direct_output_forward_char (-1);
1122 goto directly_done;
1123 }
258bf746 1124 else if (EQ (this_command, Qself_insert_command)
284f4730
JB
1125 /* Try this optimization only on ascii keystrokes. */
1126 && XTYPE (last_command_char) == Lisp_Int)
1127 {
1128 unsigned char c = XINT (last_command_char);
1129
1130 if (NILP (Vexecuting_macro) &&
1131 !EQ (minibuf_window, selected_window))
1132 {
1133 if (!nonundocount || nonundocount >= 20)
1134 {
1135 Fundo_boundary ();
1136 nonundocount = 0;
1137 }
1138 nonundocount++;
1139 }
1140 lose = (XFASTINT (XWINDOW (selected_window)->last_modified)
1141 < MODIFF)
1142 || (XFASTINT (XWINDOW (selected_window)->last_point)
1143 != point)
1144 || MODIFF <= current_buffer->save_modified
1145 || windows_or_buffers_changed
1146 || !EQ (current_buffer->selective_display, Qnil)
1147 || detect_input_pending ()
1148 || !NILP (Vexecuting_macro);
b8d9050d 1149 if (internal_self_insert (c, 0))
284f4730
JB
1150 {
1151 lose = 1;
1152 nonundocount = 0;
1153 }
1154 if (!lose &&
1155 (point == ZV || FETCH_CHAR (point) == '\n'))
1156 {
1157 struct Lisp_Vector *dp
1158 = window_display_table (XWINDOW (selected_window));
b8d9050d 1159 int lose = c;
284f4730 1160
0f7a8fee
JB
1161 if (dp)
1162 {
9b8eb840 1163 Lisp_Object obj;
0f7a8fee 1164
9b8eb840 1165 obj = DISP_CHAR_VECTOR (dp, lose);
0f7a8fee
JB
1166 if (XTYPE (obj) == Lisp_Vector
1167 && XVECTOR (obj)->size == 1
1168 && (XTYPE (obj = XVECTOR (obj)->contents[0])
1169 == Lisp_Int))
1170 no_redisplay =
1171 direct_output_for_insert (XINT (obj));
1172 }
1173 else
1174 {
1175 if (lose >= 0x20 && lose <= 0x7e)
1176 no_redisplay = direct_output_for_insert (lose);
1177 }
284f4730
JB
1178 }
1179 goto directly_done;
1180 }
1181 }
1182
1183 /* Here for a command that isn't executed directly */
1184
1185 nonundocount = 0;
1186 if (NILP (Vprefix_arg))
1187 Fundo_boundary ();
258bf746 1188 Fcommand_execute (this_command, Qnil);
284f4730 1189
284f4730 1190 }
a764a753 1191 directly_done: ;
284f4730 1192
88ce066e 1193 if (!NILP (Vpost_command_hook) && !NILP (Vrun_hooks))
b0f2a7bf
KH
1194 {
1195 /* If we get an error during the post-command-hook,
1196 cause post-command-hook to be nil. */
1197 Vcommand_hook_internal = Vpost_command_hook;
1198 Vpost_command_hook = Qnil;
1199
1200 call1 (Vrun_hooks, Qcommand_hook_internal);
1201
1202 Vpost_command_hook = Vcommand_hook_internal;
1203 }
86e5706b 1204
284f4730
JB
1205 /* If there is a prefix argument,
1206 1) We don't want last_command to be ``universal-argument''
1207 (that would be dumb), so don't set last_command,
1208 2) we want to leave echoing on so that the prefix will be
1209 echoed as part of this key sequence, so don't call
1210 cancel_echoing, and
1211 3) we want to leave this_command_key_count non-zero, so that
1212 read_char will realize that it is re-reading a character, and
1213 not echo it a second time. */
1214 if (NILP (Vprefix_arg))
1215 {
1216 last_command = this_command;
1217 cancel_echoing ();
1218 this_command_key_count = 0;
1219 }
86e5706b 1220
88ce066e 1221 if (!NILP (current_buffer->mark_active) && !NILP (Vrun_hooks))
86e5706b
RS
1222 {
1223 if (!NILP (Vdeactivate_mark) && !NILP (Vtransient_mark_mode))
1224 {
1225 current_buffer->mark_active = Qnil;
1226 call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
1227 }
1228 else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
1229 call1 (Vrun_hooks, intern ("activate-mark-hook"));
1230 }
284f4730
JB
1231 }
1232}
1233\f
1234/* Number of seconds between polling for input. */
1235int polling_period;
1236
eb8c3be9 1237/* Nonzero means polling for input is temporarily suppressed. */
284f4730
JB
1238int poll_suppress_count;
1239
1240#ifdef POLL_FOR_INPUT
1241int polling_for_input;
1242
1243/* Handle an alarm once each second and read pending input
1244 so as to handle a C-g if it comces in. */
1245
1246SIGTYPE
1247input_poll_signal ()
1248{
9ac0d9e0
JB
1249 if (interrupt_input_blocked == 0
1250 && !waiting_for_input)
1251 read_avail_input (0);
284f4730
JB
1252 signal (SIGALRM, input_poll_signal);
1253 alarm (polling_period);
1254}
1255
1256#endif
1257
1258/* Begin signals to poll for input, if they are appropriate.
1259 This function is called unconditionally from various places. */
1260
1261start_polling ()
1262{
1263#ifdef POLL_FOR_INPUT
34f04431 1264 if (read_socket_hook && !interrupt_input)
284f4730
JB
1265 {
1266 poll_suppress_count--;
1267 if (poll_suppress_count == 0)
1268 {
1269 signal (SIGALRM, input_poll_signal);
1270 polling_for_input = 1;
1271 alarm (polling_period);
1272 }
1273 }
1274#endif
1275}
1276
1277/* Turn off polling. */
1278
1279stop_polling ()
1280{
1281#ifdef POLL_FOR_INPUT
34f04431 1282 if (read_socket_hook && !interrupt_input)
284f4730
JB
1283 {
1284 if (poll_suppress_count == 0)
1285 {
1286 polling_for_input = 0;
1287 alarm (0);
1288 }
1289 poll_suppress_count++;
1290 }
1291#endif
1292}
fe8aeef3
RS
1293
1294/* Set the value of poll_suppress_count to COUNT
1295 and start or stop polling accordingly. */
1296
1297void
1298set_poll_suppress_count (count)
1299 int count;
1300{
1301#ifdef POLL_FOR_INPUT
1302 if (count == 0 && poll_suppress_count != 0)
1303 {
1304 poll_suppress_count = 1;
1305 start_polling ();
1306 }
1307 else if (count != 0 && poll_suppress_count == 0)
1308 {
1309 stop_polling ();
1310 }
1311 poll_suppress_count = count;
1312#endif
1313}
284f4730 1314\f
faf5e407
JB
1315/* Applying the control modifier to CHARACTER. */
1316int
1317make_ctrl_char (c)
1318 int c;
1319{
d205953b
JB
1320 /* Save the upper bits here. */
1321 int upper = c & ~0177;
1322
1323 c &= 0177;
1324
1325 /* Everything in the columns containing the upper-case letters
1326 denotes a control character. */
1327 if (c >= 0100 && c < 0140)
1328 {
1329 int oc = c;
1330 c &= ~0140;
1331 /* Set the shift modifier for a control char
1332 made from a shifted letter. But only for letters! */
1333 if (oc >= 'A' && oc <= 'Z')
1334 c |= shift_modifier;
1335 }
1336
1337 /* The lower-case letters denote control characters too. */
1338 else if (c >= 'a' && c <= 'z')
1339 c &= ~0140;
1340
1341 /* Include the bits for control and shift
1342 only if the basic ASCII code can't indicate them. */
1343 else if (c >= ' ')
1344 c |= ctrl_modifier;
1345
1346 /* Replace the high bits. */
1347 c |= (upper & ~ctrl_modifier);
faf5e407
JB
1348
1349 return c;
1350}
1351
1352
1353\f
284f4730
JB
1354/* Input of single characters from keyboard */
1355
1356Lisp_Object print_help ();
1357static Lisp_Object kbd_buffer_get_event ();
1358
1359/* read a character from the keyboard; call the redisplay if needed */
1360/* commandflag 0 means do not do auto-saving, but do do redisplay.
1361 -1 means do not do redisplay, but do do autosaving.
1362 1 means do both. */
1363
7d6de002
RS
1364/* The arguments MAPS and NMAPS are for menu prompting.
1365 MAPS is an array of keymaps; NMAPS is the length of MAPS.
1366
1367 PREV_EVENT is the previous input event, or nil if we are reading
1368 the first event of a key sequence.
1369
6569cc8d
JB
1370 If USED_MOUSE_MENU is non-zero, then we set *USED_MOUSE_MENU to 1
1371 if we used a mouse menu to read the input, or zero otherwise. If
dcc408a0
RS
1372 USED_MOUSE_MENU is zero, *USED_MOUSE_MENU is left alone.
1373
1374 Value is t if we showed a menu and the user rejected it. */
7d6de002 1375
284f4730 1376Lisp_Object
7d6de002 1377read_char (commandflag, nmaps, maps, prev_event, used_mouse_menu)
284f4730 1378 int commandflag;
7d6de002
RS
1379 int nmaps;
1380 Lisp_Object *maps;
1381 Lisp_Object prev_event;
1382 int *used_mouse_menu;
284f4730
JB
1383{
1384 register Lisp_Object c;
1385 int count;
1386 jmp_buf save_jump;
1387
24597608 1388 if (CONSP (Vunread_command_events))
284f4730 1389 {
24597608
RS
1390 c = XCONS (Vunread_command_events)->car;
1391 Vunread_command_events = XCONS (Vunread_command_events)->cdr;
284f4730 1392
284f4730
JB
1393 if (this_command_key_count == 0)
1394 goto reread_first;
1395 else
1396 goto reread;
1397 }
1398
86e5706b
RS
1399 if (unread_command_char != -1)
1400 {
1401 XSET (c, Lisp_Int, unread_command_char);
1402 unread_command_char = -1;
1403
1404 if (this_command_key_count == 0)
1405 goto reread_first;
1406 else
1407 goto reread;
1408 }
1409
284f4730
JB
1410 if (!NILP (Vexecuting_macro))
1411 {
07d2b8de 1412#ifdef MULTI_FRAME
fce33686
JB
1413 /* We set this to Qmacro; since that's not a frame, nobody will
1414 try to switch frames on us, and the selected window will
1415 remain unchanged.
1416
1417 Since this event came from a macro, it would be misleading to
eb8c3be9 1418 leave internal_last_event_frame set to wherever the last
3c370943
JB
1419 real event came from. Normally, a switch-frame event selects
1420 internal_last_event_frame after each command is read, but
1421 events read from a macro should never cause a new frame to be
1422 selected. */
1423 Vlast_event_frame = internal_last_event_frame = Qmacro;
07d2b8de 1424#endif
fce33686 1425
663258f2
JB
1426 /* Exit the macro if we are at the end.
1427 Also, some things replace the macro with t
1428 to force an early exit. */
1429 if (EQ (Vexecuting_macro, Qt)
1430 || executing_macro_index >= XFASTINT (Flength (Vexecuting_macro)))
284f4730
JB
1431 {
1432 XSET (c, Lisp_Int, -1);
1433 return c;
1434 }
1435
1436 c = Faref (Vexecuting_macro, make_number (executing_macro_index));
86e5706b
RS
1437 if (XTYPE (Vexecuting_macro) == Lisp_String
1438 && (XINT (c) & 0x80))
1439 XFASTINT (c) = CHAR_META | (XINT (c) & ~0x80);
1440
284f4730
JB
1441 executing_macro_index++;
1442
1443 goto from_macro;
1444 }
1445
cd21b839
JB
1446 if (!NILP (unread_switch_frame))
1447 {
1448 c = unread_switch_frame;
1449 unread_switch_frame = Qnil;
1450
1451 /* This event should make it into this_command_keys, and get echoed
f4255cd1
JB
1452 again, so we go to reread_first, rather than reread. */
1453 goto reread_first;
cd21b839
JB
1454 }
1455
3f9929bf
RS
1456 /* Don't bother updating menu bars while doing mouse tracking.
1457 We get events very rapidly then, and the menu bar won't be changing.
1458 We do update the menu bar once on entry to Ftrack_mouse. */
1459 if (!do_mouse_tracking &&
1460 commandflag >= 0 && !input_pending && !detect_input_pending ())
e9bf89a0
RS
1461 prepare_menu_bars ();
1462
284f4730 1463 /* Save outer setjmp data, in case called recursively. */
f76475ad 1464 save_getcjmp (save_jump);
284f4730
JB
1465
1466 stop_polling ();
1467
1468 if (commandflag >= 0 && !input_pending && !detect_input_pending ())
1469 redisplay ();
1470
1471 if (_setjmp (getcjmp))
1472 {
1473 XSET (c, Lisp_Int, quit_char);
07d2b8de 1474#ifdef MULTI_FRAME
3c370943
JB
1475 XSET (internal_last_event_frame, Lisp_Frame, selected_frame);
1476 Vlast_event_frame = internal_last_event_frame;
07d2b8de 1477#endif
04904c29
RS
1478 /* If we report the quit char as an event,
1479 don't do so more than once. */
1480 if (!NILP (Vinhibit_quit))
1481 Vquit_flag = Qnil;
284f4730 1482
284f4730
JB
1483 goto non_reread;
1484 }
1485
1486 /* Message turns off echoing unless more keystrokes turn it on again. */
1487 if (echo_area_glyphs && *echo_area_glyphs && echo_area_glyphs != echobuf)
1488 cancel_echoing ();
1489 else
1490 /* If already echoing, continue. */
1491 echo_dash ();
1492
8150596a
RS
1493 /* Try reading a character via menu prompting in the minibuf.
1494 Try this before the sit-for, because the sit-for
1495 would do the wrong thing if we are supposed to do
1496 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
1497 after a mouse event so don't try a minibuf menu. */
1498 c = Qnil;
24597608
RS
1499 if (nmaps > 0 && INTERACTIVE
1500 && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
1501 /* Don't bring up a menu if we already have another event. */
1502 && NILP (Vunread_command_events)
1503 && unread_command_char < 0
1504 && EVENT_QUEUES_EMPTY)
8150596a
RS
1505 {
1506 c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
24597608
RS
1507 if (! NILP (c))
1508 return c;
8150596a
RS
1509 }
1510
284f4730
JB
1511 /* If in middle of key sequence and minibuffer not active,
1512 start echoing if enough time elapses. */
1513 if (minibuf_level == 0 && !immediate_echo && this_command_key_count > 0
27203ead 1514 && ! noninteractive
284f4730
JB
1515 && echo_keystrokes > 0
1516 && (echo_area_glyphs == 0 || *echo_area_glyphs == 0))
1517 {
1518 Lisp_Object tem0;
1519
7d6de002
RS
1520 /* After a mouse event, start echoing right away.
1521 This is because we are probably about to display a menu,
1522 and we don't want to delay before doing so. */
dbc4e1c1 1523 if (EVENT_HAS_PARAMETERS (prev_event))
284f4730 1524 echo ();
7d6de002
RS
1525 else
1526 {
1527 tem0 = sit_for (echo_keystrokes, 0, 1, 1);
1528 if (EQ (tem0, Qt))
1529 echo ();
1530 }
284f4730
JB
1531 }
1532
1533 /* Maybe auto save due to number of keystrokes or idle time. */
1534
1535 if (commandflag != 0
1536 && auto_save_interval > 0
51172b6d 1537 && num_nonmacro_input_chars - last_auto_save > max (auto_save_interval, 20)
284f4730
JB
1538 && !detect_input_pending ())
1539 {
1540 jmp_buf temp;
1541 save_getcjmp (temp);
1542 Fdo_auto_save (Qnil, Qnil);
1543 restore_getcjmp (temp);
1544 }
1545
8150596a 1546 /* Try reading using an X menu.
24597608
RS
1547 This is never confused with reading using the minibuf
1548 because the recursive call of read_char in read_char_minibuf_menu_prompt
1549 does not pass on any keymaps. */
1550 if (nmaps > 0 && INTERACTIVE
1551 && !NILP (prev_event) && EVENT_HAS_PARAMETERS (prev_event)
1552 /* Don't bring up a menu if we already have another event. */
1553 && NILP (Vunread_command_events)
1554 && unread_command_char < 0
1555 && EVENT_QUEUES_EMPTY)
8150596a 1556 c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
7d6de002 1557
284f4730
JB
1558 /* Slow down auto saves logarithmically in size of current buffer,
1559 and garbage collect while we're at it. */
26c1639e 1560 if (INTERACTIVE && NILP (c))
7d6de002
RS
1561 {
1562 int delay_level, buffer_size;
1563
1564 if (! MINI_WINDOW_P (XWINDOW (selected_window)))
1565 last_non_minibuf_size = Z - BEG;
1566 buffer_size = (last_non_minibuf_size >> 8) + 1;
1567 delay_level = 0;
1568 while (buffer_size > 64)
1569 delay_level++, buffer_size -= buffer_size >> 2;
1570 if (delay_level < 4) delay_level = 4;
1571 /* delay_level is 4 for files under around 50k, 7 at 100k,
1572 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
1573
1574 /* Auto save if enough time goes by without input. */
1575 if (commandflag != 0
51172b6d 1576 && num_nonmacro_input_chars > last_auto_save
7d6de002
RS
1577 && XTYPE (Vauto_save_timeout) == Lisp_Int
1578 && XINT (Vauto_save_timeout) > 0)
1579 {
1580 Lisp_Object tem0;
1581 int delay = delay_level * XFASTINT (Vauto_save_timeout) / 4;
1582 tem0 = sit_for (delay, 0, 1, 1);
1583 if (EQ (tem0, Qt))
1584 {
1585 jmp_buf temp;
1586 save_getcjmp (temp);
1587 Fdo_auto_save (Qnil, Qnil);
1588 restore_getcjmp (temp);
1589
1590 /* If we have auto-saved and there is still no input
1591 available, garbage collect if there has been enough
1592 consing going on to make it worthwhile. */
1593 if (!detect_input_pending ()
1594 && consing_since_gc > gc_cons_threshold / 2)
7e85b935
RS
1595 {
1596 Fgarbage_collect ();
e9bf89a0
RS
1597 /* prepare_menu_bars isn't safe here, but it should
1598 also be unnecessary. */
7e85b935
RS
1599 redisplay ();
1600 }
7d6de002
RS
1601 }
1602 }
1603 }
284f4730
JB
1604
1605 /* Actually read a character, waiting if necessary. */
4eb4f926 1606 while (NILP (c))
1e12dd87
RS
1607 {
1608 c = kbd_buffer_get_event ();
1609 if (!NILP (c))
1610 break;
1611 if (commandflag >= 0 && !input_pending && !detect_input_pending ())
1612 redisplay ();
1613 }
284f4730 1614
284f4730 1615 /* Terminate Emacs in batch mode if at eof. */
7d6de002 1616 if (noninteractive && XTYPE (c) == Lisp_Int && XINT (c) < 0)
284f4730
JB
1617 Fkill_emacs (make_number (1));
1618
80645119
JB
1619 if (XTYPE (c) == Lisp_Int)
1620 {
1621 /* Add in any extra modifiers, where appropriate. */
1622 if ((extra_keyboard_modifiers & CHAR_CTL)
1623 || ((extra_keyboard_modifiers & 0177) < ' '
1624 && (extra_keyboard_modifiers & 0177) != 0))
faf5e407 1625 XSETINT (c, make_ctrl_char (XINT (c)));
80645119
JB
1626
1627 /* Transfer any other modifier bits directly from
1628 extra_keyboard_modifiers to c. Ignore the actual character code
1629 in the low 16 bits of extra_keyboard_modifiers. */
b8d9050d 1630 XSETINT (c, XINT (c) | (extra_keyboard_modifiers & ~0xff7f & ~CHAR_CTL));
80645119 1631 }
9fa4395d 1632
284f4730
JB
1633 non_reread:
1634
f76475ad 1635 restore_getcjmp (save_jump);
284f4730
JB
1636
1637 start_polling ();
1638
1639 echo_area_glyphs = 0;
1640
1641 /* Handle things that only apply to characters. */
1642 if (XTYPE (c) == Lisp_Int)
1643 {
1644 /* If kbd_buffer_get_event gave us an EOF, return that. */
86e5706b 1645 if (XINT (c) == -1)
284f4730
JB
1646 return c;
1647
284f4730 1648 if (XTYPE (Vkeyboard_translate_table) == Lisp_String
f4255cd1
JB
1649 && XSTRING (Vkeyboard_translate_table)->size > XFASTINT (c))
1650 XSETINT (c, XSTRING (Vkeyboard_translate_table)->data[XFASTINT (c)]);
284f4730
JB
1651 }
1652
1653 total_keys++;
5160df46
JB
1654 XVECTOR (recent_keys)->contents[recent_keys_index] = c;
1655 if (++recent_keys_index >= NUM_RECENT_KEYS)
284f4730
JB
1656 recent_keys_index = 0;
1657
1658 /* Write c to the dribble file. If c is a lispy event, write
1659 the event's symbol to the dribble file, in <brackets>. Bleaugh.
1660 If you, dear reader, have a better idea, you've got the source. :-) */
1661 if (dribble)
1662 {
1663 if (XTYPE (c) == Lisp_Int)
f4255cd1 1664 putc (XINT (c), dribble);
284f4730
JB
1665 else
1666 {
9b8eb840 1667 Lisp_Object dribblee;
284f4730
JB
1668
1669 /* If it's a structured event, take the event header. */
9b8eb840 1670 dribblee = EVENT_HEAD (c);
284f4730 1671
8f805655 1672 if (XTYPE (dribblee) == Lisp_Symbol)
284f4730
JB
1673 {
1674 putc ('<', dribble);
8f805655
JB
1675 fwrite (XSYMBOL (dribblee)->name->data, sizeof (char),
1676 XSYMBOL (dribblee)->name->size,
284f4730
JB
1677 dribble);
1678 putc ('>', dribble);
1679 }
1680 }
1681
1682 fflush (dribble);
1683 }
1684
1685 store_kbd_macro_char (c);
1686
51172b6d
RS
1687 num_nonmacro_input_chars++;
1688
284f4730
JB
1689 from_macro:
1690 reread_first:
284f4730 1691
4bb994d1
JB
1692 /* Record this character as part of the current key.
1693 Don't record mouse motion; it should never matter. */
1694 if (! (EVENT_HAS_PARAMETERS (c)
1695 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_movement)))
7b4aedb9
JB
1696 {
1697 echo_char (c);
1698 add_command_key (c);
1699 }
284f4730
JB
1700
1701 /* Re-reading in the middle of a command */
1702 reread:
1703 last_input_char = c;
1704 num_input_chars++;
1705
1706 /* Process the help character specially if enabled */
7e85b935 1707 if (EQ (c, Vhelp_char) && !NILP (Vhelp_form))
284f4730
JB
1708 {
1709 Lisp_Object tem0;
1710 count = specpdl_ptr - specpdl;
1711
1712 record_unwind_protect (Fset_window_configuration,
1713 Fcurrent_window_configuration (Qnil));
1714
1715 tem0 = Feval (Vhelp_form);
1716 if (XTYPE (tem0) == Lisp_String)
1717 internal_with_output_to_temp_buffer ("*Help*", print_help, tem0);
1718
1719 cancel_echoing ();
3cb81011
KH
1720 do
1721 c = read_char (0, 0, 0, Qnil, 0);
1722 while (XTYPE (c) == Lisp_Buffer);
ff11dfa1 1723 /* Remove the help from the frame */
284f4730 1724 unbind_to (count, Qnil);
e9bf89a0 1725 prepare_menu_bars ();
284f4730
JB
1726 redisplay ();
1727 if (EQ (c, make_number (040)))
1728 {
1729 cancel_echoing ();
3cb81011
KH
1730 do
1731 c = read_char (0, 0, 0, Qnil, 0);
1732 while (XTYPE (c) == Lisp_Buffer);
284f4730
JB
1733 }
1734 }
1735
1736 return c;
1737}
1738
1739Lisp_Object
1740print_help (object)
1741 Lisp_Object object;
1742{
1743 Fprinc (object, Qnil);
1744 return Qnil;
1745}
1746
1747/* Copy out or in the info on where C-g should throw to.
1748 This is used when running Lisp code from within get_char,
1749 in case get_char is called recursively.
1750 See read_process_output. */
1751
1752save_getcjmp (temp)
1753 jmp_buf temp;
1754{
1755 bcopy (getcjmp, temp, sizeof getcjmp);
1756}
1757
1758restore_getcjmp (temp)
1759 jmp_buf temp;
1760{
1761 bcopy (temp, getcjmp, sizeof getcjmp);
1762}
1763
1764\f
284f4730
JB
1765/* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1766 of this function. */
1767static Lisp_Object
1768tracking_off (old_value)
1769 Lisp_Object old_value;
1770{
1771 if (! XFASTINT (old_value))
1772 {
1773 do_mouse_tracking = 0;
1774
1775 /* Redisplay may have been preempted because there was input
1776 available, and it assumes it will be called again after the
1777 input has been processed. If the only input available was
1778 the sort that we have just disabled, then we need to call
1779 redisplay. */
1780 if (!readable_events ())
1781 {
e9bf89a0 1782 prepare_menu_bars ();
284f4730
JB
1783 redisplay_preserve_echo_area ();
1784 get_input_pending (&input_pending);
1785 }
1786 }
1787}
1788
1789DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
4bb994d1
JB
1790 "Evaluate BODY with mouse movement events enabled.\n\
1791Within a `track-mouse' form, mouse motion generates input events that\n\
1792you can read with `read-event'.\n\
1793Normally, mouse motion is ignored.")
284f4730
JB
1794 (args)
1795 Lisp_Object args;
1796{
1797 int count = specpdl_ptr - specpdl;
1798 Lisp_Object val;
1799
1800 XSET (val, Lisp_Int, do_mouse_tracking);
1801 record_unwind_protect (tracking_off, val);
1802
3f9929bf
RS
1803 if (!input_pending && !detect_input_pending ())
1804 prepare_menu_bars ();
1805
284f4730
JB
1806 do_mouse_tracking = 1;
1807
1808 val = Fprogn (args);
1809 return unbind_to (count, val);
1810}
a612e298
RS
1811\f
1812/* Low level keyboard/mouse input.
1813 kbd_buffer_store_event places events in kbd_buffer, and
1814 kbd_buffer_get_event retrieves them.
1815 mouse_moved indicates when the mouse has moved again, and
1816 *mouse_position_hook provides the mouse position. */
1817
1818/* Return true iff there are any events in the queue that read-char
1819 would return. If this returns false, a read-char would block. */
1820static int
1821readable_events ()
1822{
1823 return ! EVENT_QUEUES_EMPTY;
1824}
1825
1826/* Set this for debugging, to have a way to get out */
1827int stop_character;
284f4730
JB
1828
1829/* Store an event obtained at interrupt level into kbd_buffer, fifo */
1830
1831void
1832kbd_buffer_store_event (event)
1833 register struct input_event *event;
1834{
1835 if (event->kind == no_event)
1836 abort ();
1837
1838 if (event->kind == ascii_keystroke)
1839 {
e9bf89a0 1840 register int c = event->code & 0377;
284f4730 1841
faf5e407
JB
1842 if (event->modifiers & ctrl_modifier)
1843 c = make_ctrl_char (c);
1844
9fd7d808
RS
1845 c |= (event->modifiers
1846 & (meta_modifier | alt_modifier
1847 | hyper_modifier | super_modifier));
1848
86e5706b 1849 if (c == quit_char)
284f4730 1850 {
3e51c7b7
JB
1851 extern SIGTYPE interrupt_signal ();
1852
07d2b8de 1853#ifdef MULTI_FRAME
284f4730 1854 /* If this results in a quit_char being returned to Emacs as
3c370943 1855 input, set Vlast_event_frame properly. If this doesn't
284f4730 1856 get returned to Emacs as an event, the next event read
ff11dfa1 1857 will set Vlast_event_frame again, so this is safe to do. */
4bb994d1 1858 {
9b8eb840 1859 Lisp_Object focus;
4bb994d1 1860
9b8eb840 1861 focus = FRAME_FOCUS_FRAME (XFRAME (event->frame_or_window));
4bb994d1 1862 if (NILP (focus))
3c370943 1863 internal_last_event_frame = event->frame_or_window;
4bb994d1 1864 else
3c370943
JB
1865 internal_last_event_frame = focus;
1866 Vlast_event_frame = internal_last_event_frame;
4bb994d1 1867 }
07d2b8de 1868#endif
3e51c7b7 1869
ffd56f97 1870 last_event_timestamp = event->timestamp;
284f4730
JB
1871 interrupt_signal ();
1872 return;
1873 }
1874
1875 if (c && c == stop_character)
1876 {
1877 sys_suspend ();
1878 return;
1879 }
284f4730
JB
1880 }
1881
1882 if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
1883 kbd_store_ptr = kbd_buffer;
1884
1885 /* Don't let the very last slot in the buffer become full,
1886 since that would make the two pointers equal,
1887 and that is indistinguishable from an empty buffer.
1888 Discard the event if it would fill the last slot. */
1889 if (kbd_fetch_ptr - 1 != kbd_store_ptr)
1890 {
1891 kbd_store_ptr->kind = event->kind;
27203ead
RS
1892 if (event->kind == selection_request_event)
1893 {
1894 /* We must not use the ordinary copying code for this case,
1895 since `part' is an enum and copying it might not copy enough
1896 in this case. */
1897 bcopy (event, kbd_store_ptr, sizeof (*event));
1898 }
1899 else
1900 {
1901 kbd_store_ptr->code = event->code;
1902 kbd_store_ptr->part = event->part;
1903 kbd_store_ptr->frame_or_window = event->frame_or_window;
1904 kbd_store_ptr->modifiers = event->modifiers;
1905 kbd_store_ptr->x = event->x;
1906 kbd_store_ptr->y = event->y;
1907 kbd_store_ptr->timestamp = event->timestamp;
1908 }
7b4aedb9
JB
1909 (XVECTOR (kbd_buffer_frame_or_window)->contents[kbd_store_ptr
1910 - kbd_buffer]
1911 = event->frame_or_window);
284f4730
JB
1912
1913 kbd_store_ptr++;
1914 }
1915}
a612e298
RS
1916\f
1917/* Read one event from the event buffer, waiting if necessary.
1918 The value is a Lisp object representing the event.
1919 The value is nil for an event that should be ignored,
1920 or that was handled here.
1921 We always read and discard one event. */
284f4730
JB
1922
1923static Lisp_Object
1924kbd_buffer_get_event ()
1925{
1926 register int c;
1927 Lisp_Object obj;
1928
1929 if (noninteractive)
1930 {
1931 c = getchar ();
1932 XSET (obj, Lisp_Int, c);
1933 return obj;
1934 }
1935
1936 /* Wait until there is input available. */
1937 for (;;)
1938 {
284f4730
JB
1939 if (!EVENT_QUEUES_EMPTY)
1940 break;
1941
1942 /* If the quit flag is set, then read_char will return
1943 quit_char, so that counts as "available input." */
1944 if (!NILP (Vquit_flag))
1945 quit_throw_to_read_char ();
1946
1947 /* One way or another, wait until input is available; then, if
1948 interrupt handlers have not read it, read it now. */
1949
1950#ifdef OLDVMS
1951 wait_for_kbd_input ();
1952#else
1953/* Note SIGIO has been undef'd if FIONREAD is missing. */
1954#ifdef SIGIO
1955 gobble_input (0);
1956#endif /* SIGIO */
1957 if (EVENT_QUEUES_EMPTY)
1958 {
f76475ad
JB
1959 Lisp_Object minus_one;
1960
1961 XSET (minus_one, Lisp_Int, -1);
1962 wait_reading_process_input (0, 0, minus_one, 1);
284f4730
JB
1963
1964 if (!interrupt_input && EVENT_QUEUES_EMPTY)
bedae5a5
RS
1965 /* Pass 1 for EXPECT since we just waited to have input. */
1966 read_avail_input (1);
284f4730
JB
1967 }
1968#endif /* not VMS */
1969 }
1970
1971 /* At this point, we know that there is a readable event available
1972 somewhere. If the event queue is empty, then there must be a
1973 mouse movement enabled and available. */
1974 if (kbd_fetch_ptr != kbd_store_ptr)
1975 {
cd21b839 1976 struct input_event *event;
3e51c7b7 1977
856bf263 1978 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
cd21b839
JB
1979 ? kbd_fetch_ptr
1980 : kbd_buffer);
3e51c7b7 1981
cd21b839 1982 last_event_timestamp = event->timestamp;
cd21b839 1983
4bb994d1
JB
1984 obj = Qnil;
1985
48e416d4 1986 /* These two kinds of events get special handling
a612e298
RS
1987 and don't actually appear to the command loop.
1988 We return nil for them. */
48e416d4
RS
1989 if (event->kind == selection_request_event)
1990 {
598a9fa7 1991#ifdef HAVE_X11
48e416d4
RS
1992 x_handle_selection_request (event);
1993 kbd_fetch_ptr = event + 1;
598a9fa7
JB
1994#else
1995 /* We're getting selection request events, but we don't have
1996 a window system. */
1997 abort ();
1998#endif
48e416d4
RS
1999 }
2000
1e12dd87 2001 else if (event->kind == selection_clear_event)
48e416d4 2002 {
598a9fa7 2003#ifdef HAVE_X11
48e416d4
RS
2004 x_handle_selection_clear (event);
2005 kbd_fetch_ptr = event + 1;
598a9fa7
JB
2006#else
2007 /* We're getting selection request events, but we don't have
2008 a window system. */
2009 abort ();
2010#endif
48e416d4 2011 }
990acea3
RS
2012#ifdef HAVE_X11
2013 else if (event->kind == delete_window_event)
2014 {
58f6c8ab
RS
2015 Lisp_Object tail, frame;
2016 struct frame *f;
2017
2018 /* If the user destroys the only frame, Emacs should exit.
2019 Count visible frames and iconified frames. */
2020 for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
2021 {
2022 frame = XCONS (tail)->car;
2023 if (XTYPE (frame) != Lisp_Frame || EQ (frame, event->frame_or_window))
2024 continue;
2025 f = XFRAME (frame);
2026 if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
2027 break;
2028 }
990acea3 2029
58f6c8ab 2030 if (! CONSP (tail))
80e4aa30 2031 Fkill_emacs (Qnil);
854f3a54
RS
2032
2033 Fdelete_frame (event->frame_or_window, Qt);
2034 kbd_fetch_ptr = event + 1;
990acea3
RS
2035 }
2036#endif
f5e09c8b
RS
2037 else if (event->kind == menu_bar_event)
2038 {
2039 /* The event value is in the frame_or_window slot. */
2040 obj = event->frame_or_window;
2041 kbd_fetch_ptr = event + 1;
2042 }
a8015ab5
KH
2043 else if (event->kind == buffer_switch_event)
2044 {
2045 /* The value doesn't matter here; only the type is tested. */
2046 XSET (obj, Lisp_Buffer, current_buffer);
2047 kbd_fetch_ptr = event + 1;
2048 }
a612e298
RS
2049 /* Just discard these, by returning nil.
2050 (They shouldn't be found in the buffer,
2051 but on some machines it appears they do show up.) */
2052 else if (event->kind == no_event)
2053 kbd_fetch_ptr = event + 1;
48e416d4 2054
4bb994d1
JB
2055 /* If this event is on a different frame, return a switch-frame this
2056 time, and leave the event in the queue for next time. */
1e12dd87
RS
2057 else
2058 {
a6d53864 2059#ifdef MULTI_FRAME
9b8eb840 2060 Lisp_Object frame;
1e12dd87 2061 Lisp_Object focus;
7b4aedb9 2062
9b8eb840 2063 frame = event->frame_or_window;
1e12dd87
RS
2064 if (XTYPE (frame) == Lisp_Window)
2065 frame = WINDOW_FRAME (XWINDOW (frame));
4bb994d1 2066
1e12dd87
RS
2067 focus = FRAME_FOCUS_FRAME (XFRAME (frame));
2068 if (! NILP (focus))
2069 frame = focus;
07d2b8de 2070
1e12dd87
RS
2071 if (! EQ (frame, internal_last_event_frame)
2072 && XFRAME (frame) != selected_frame)
2073 obj = make_lispy_switch_frame (frame);
2074 internal_last_event_frame = frame;
a6d53864 2075#endif /* MULTI_FRAME */
4bb994d1 2076
1e12dd87
RS
2077 /* If we didn't decide to make a switch-frame event, go ahead
2078 and build a real event from the queue entry. */
cd21b839 2079
1e12dd87
RS
2080 if (NILP (obj))
2081 {
2082 obj = make_lispy_event (event);
2083
2084 /* Wipe out this event, to catch bugs. */
2085 event->kind = no_event;
2086 (XVECTOR (kbd_buffer_frame_or_window)->contents[event - kbd_buffer]
2087 = Qnil);
2088
2089 kbd_fetch_ptr = event + 1;
2090 }
4bb994d1 2091 }
284f4730 2092 }
a612e298 2093 /* Try generating a mouse motion event. */
284f4730
JB
2094 else if (do_mouse_tracking && mouse_moved)
2095 {
7e85b935 2096 FRAME_PTR f = 0;
7b4aedb9 2097 Lisp_Object bar_window;
3c370943 2098 enum scroll_bar_part part;
e5d77022
JB
2099 Lisp_Object x, y;
2100 unsigned long time;
284f4730 2101
7b4aedb9 2102 (*mouse_position_hook) (&f, &bar_window, &part, &x, &y, &time);
4bb994d1
JB
2103
2104 obj = Qnil;
284f4730 2105
07d2b8de 2106#ifdef MULTI_FRAME
4bb994d1
JB
2107 /* Decide if we should generate a switch-frame event. Don't
2108 generate switch-frame events for motion outside of all Emacs
2109 frames. */
2110 if (f)
cd21b839 2111 {
9b8eb840 2112 Lisp_Object frame;
4bb994d1 2113
9b8eb840 2114 frame = FRAME_FOCUS_FRAME (f);
4bb994d1
JB
2115 if (NILP (frame))
2116 XSET (frame, Lisp_Frame, f);
2117
80645119
JB
2118 if (! EQ (frame, internal_last_event_frame)
2119 && XFRAME (frame) != selected_frame)
764cb3f9 2120 obj = make_lispy_switch_frame (frame);
80645119 2121 internal_last_event_frame = frame;
cd21b839 2122 }
4bb994d1
JB
2123
2124 /* If we didn't decide to make a switch-frame event, go ahead and
2125 return a mouse-motion event. */
2126 if (NILP (obj))
7b4aedb9 2127 obj = make_lispy_movement (f, bar_window, part, x, y, time);
6cbff1cb
RS
2128#endif
2129 }
284f4730
JB
2130 else
2131 /* We were promised by the above while loop that there was
2132 something for us to read! */
2133 abort ();
2134
2135 input_pending = readable_events ();
2136
3c370943
JB
2137#ifdef MULTI_FRAME
2138 Vlast_event_frame = internal_last_event_frame;
2139#endif
2140
284f4730
JB
2141 return (obj);
2142}
a612e298
RS
2143\f
2144/* Process any events that are not user-visible,
2145 then return, without reading any user-visible events. */
3a3b9632
RS
2146
2147void
2148swallow_events ()
2149{
2150 while (kbd_fetch_ptr != kbd_store_ptr)
2151 {
2152 struct input_event *event;
2153
2154 event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
2155 ? kbd_fetch_ptr
2156 : kbd_buffer);
2157
2158 last_event_timestamp = event->timestamp;
2159
2160 /* These two kinds of events get special handling
2161 and don't actually appear to the command loop. */
2162 if (event->kind == selection_request_event)
2163 {
2164#ifdef HAVE_X11
2165 x_handle_selection_request (event);
2166 kbd_fetch_ptr = event + 1;
2167#else
2168 /* We're getting selection request events, but we don't have
2169 a window system. */
2170 abort ();
2171#endif
2172 }
2173
2174 else if (event->kind == selection_clear_event)
2175 {
2176#ifdef HAVE_X11
2177 x_handle_selection_clear (event);
2178 kbd_fetch_ptr = event + 1;
2179#else
2180 /* We're getting selection request events, but we don't have
2181 a window system. */
2182 abort ();
2183#endif
2184 }
2185 else
2186 break;
2187 }
2188
2189 get_input_pending (&input_pending);
2190}
a612e298 2191\f
284f4730 2192/* Caches for modify_event_symbol. */
e9bf89a0 2193static Lisp_Object accent_key_syms;
270a208f 2194static Lisp_Object system_key_syms;
284f4730
JB
2195static Lisp_Object func_key_syms;
2196static Lisp_Object mouse_syms;
2197
270a208f 2198Lisp_Object Vsystem_key_alist;
80e4aa30 2199
e9bf89a0
RS
2200/* This is a list of keysym codes for special "accent" characters.
2201 It parallels lispy_accent_keys. */
2202
2203static int lispy_accent_codes[] =
2204{
79a7046c 2205#ifdef XK_dead_circumflex
e9bf89a0 2206 XK_dead_circumflex,
79a7046c
RS
2207#else
2208 0,
2209#endif
2210#ifdef XK_dead_grave
e9bf89a0 2211 XK_dead_grave,
79a7046c
RS
2212#else
2213 0,
2214#endif
2215#ifdef XK_dead_tilde
e9bf89a0 2216 XK_dead_tilde,
79a7046c
RS
2217#else
2218 0,
2219#endif
2220#ifdef XK_dead_diaeresis
e9bf89a0 2221 XK_dead_diaeresis,
79a7046c
RS
2222#else
2223 0,
2224#endif
2225#ifdef XK_dead_macron
e9bf89a0 2226 XK_dead_macron,
79a7046c
RS
2227#else
2228 0,
2229#endif
2230#ifdef XK_dead_degree
e9bf89a0 2231 XK_dead_degree,
79a7046c
RS
2232#else
2233 0,
2234#endif
2235#ifdef XK_dead_acute
e9bf89a0 2236 XK_dead_acute,
79a7046c
RS
2237#else
2238 0,
2239#endif
2240#ifdef XK_dead_cedilla
e9bf89a0 2241 XK_dead_cedilla,
79a7046c
RS
2242#else
2243 0,
2244#endif
2245#ifdef XK_dead_breve
e9bf89a0 2246 XK_dead_breve,
79a7046c
RS
2247#else
2248 0,
2249#endif
2250#ifdef XK_dead_ogonek
e9bf89a0 2251 XK_dead_ogonek,
79a7046c
RS
2252#else
2253 0,
2254#endif
2255#ifdef XK_dead_caron
e9bf89a0 2256 XK_dead_caron,
79a7046c
RS
2257#else
2258 0,
2259#endif
2260#ifdef XK_dead_doubleacute
e9bf89a0 2261 XK_dead_doubleacute,
79a7046c
RS
2262#else
2263 0,
2264#endif
2265#ifdef XK_dead_abovedot
e9bf89a0 2266 XK_dead_abovedot,
79a7046c
RS
2267#else
2268 0,
2269#endif
e9bf89a0
RS
2270};
2271
2272/* This is a list of Lisp names for special "accent" characters.
2273 It parallels lispy_accent_codes. */
2274
2275static char *lispy_accent_keys[] =
2276{
2277 "dead-circumflex",
2278 "dead-grave",
2279 "dead-tilde",
2280 "dead-diaeresis",
2281 "dead-macron",
2282 "dead-degree",
2283 "dead-acute",
2284 "dead-cedilla",
2285 "dead-breve",
2286 "dead-ogonek",
2287 "dead-caron",
2288 "dead-doubleacute",
2289 "dead-abovedot",
2290};
2291
284f4730
JB
2292/* You'll notice that this table is arranged to be conveniently
2293 indexed by X Windows keysym values. */
2294static char *lispy_function_keys[] =
2295 {
2296 /* X Keysym value */
2297
80e4aa30 2298 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00 */
86e5706b
RS
2299 "backspace",
2300 "tab",
2301 "linefeed",
2302 "clear",
2303 0,
2304 "return",
2305 0, 0,
2306 0, 0, 0, /* 0xff10 */
2307 "pause",
2308 0, 0, 0, 0, 0, 0, 0,
2309 "escape",
2310 0, 0, 0, 0,
2311 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff20...2f */
2312 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff30...3f */
2313 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
2314
284f4730
JB
2315 "home", /* 0xff50 */ /* IsCursorKey */
2316 "left",
2317 "up",
2318 "right",
2319 "down",
2320 "prior",
2321 "next",
2322 "end",
2323 "begin",
2324 0, /* 0xff59 */
2325 0, 0, 0, 0, 0, 0,
2326 "select", /* 0xff60 */ /* IsMiscFunctionKey */
2327 "print",
2328 "execute",
2329 "insert",
2330 0, /* 0xff64 */
2331 "undo",
2332 "redo",
2333 "menu",
2334 "find",
2335 "cancel",
2336 "help",
2337 "break", /* 0xff6b */
2338
80e4aa30 2339 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
284f4730 2340 0, /* 0xff76 */
36ae397e 2341 0, 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff7f */
284f4730
JB
2342 "kp-space", /* 0xff80 */ /* IsKeypadKey */
2343 0, 0, 0, 0, 0, 0, 0, 0,
2344 "kp-tab", /* 0xff89 */
2345 0, 0, 0,
2346 "kp-enter", /* 0xff8d */
2347 0, 0, 0,
2348 "kp-f1", /* 0xff91 */
2349 "kp-f2",
2350 "kp-f3",
2351 "kp-f4",
2352 0, /* 0xff95 */
2353 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2354 "kp-multiply", /* 0xffaa */
2355 "kp-add",
2356 "kp-separator",
2357 "kp-subtract",
2358 "kp-decimal",
2359 "kp-divide", /* 0xffaf */
2360 "kp-0", /* 0xffb0 */
2361 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
2362 0, /* 0xffba */
2363 0, 0,
2364 "kp-equal", /* 0xffbd */
2365 "f1", /* 0xffbe */ /* IsFunctionKey */
86e5706b
RS
2366 "f2",
2367 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
2368 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
2369 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
2370 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
2371 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
2372 0, 0, 0, 0, 0, 0, 0, 0,
2373 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
2374 0, 0, 0, 0, 0, 0, 0, "delete"
284f4730
JB
2375 };
2376
2377static char *lispy_mouse_names[] =
2378{
2379 "mouse-1", "mouse-2", "mouse-3", "mouse-4", "mouse-5"
2380};
2381
3c370943 2382/* Scroll bar parts. */
4bb994d1
JB
2383Lisp_Object Qabove_handle, Qhandle, Qbelow_handle;
2384
3c370943
JB
2385/* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
2386Lisp_Object *scroll_bar_parts[] = {
4bb994d1
JB
2387 &Qabove_handle, &Qhandle, &Qbelow_handle
2388};
2389
2390
7b4aedb9 2391/* A vector, indexed by button number, giving the down-going location
3c370943 2392 of currently depressed buttons, both scroll bar and non-scroll bar.
7b4aedb9
JB
2393
2394 The elements have the form
2395 (BUTTON-NUMBER MODIFIER-MASK . REST)
2396 where REST is the cdr of a position as it would be reported in the event.
2397
2398 The make_lispy_event function stores positions here to tell the
2399 difference between click and drag events, and to store the starting
2400 location to be included in drag events. */
2401
2402static Lisp_Object button_down_location;
88cb0656 2403
fbcd35bd
JB
2404/* Information about the most recent up-going button event: Which
2405 button, what location, and what time. */
2406
559f9d04
RS
2407static int last_mouse_button;
2408static int last_mouse_x;
2409static int last_mouse_y;
2410static unsigned long button_down_time;
fbcd35bd 2411
564dc952
JB
2412/* The maximum time between clicks to make a double-click,
2413 or Qnil to disable double-click detection,
2414 or Qt for no time limit. */
2415Lisp_Object Vdouble_click_time;
fbcd35bd
JB
2416
2417/* The number of clicks in this multiple-click. */
2418
2419int double_click_count;
2420
bb936752
FP
2421#ifdef USE_X_TOOLKIT
2422extern Lisp_Object map_event_to_object ();
2423#endif /* USE_X_TOOLKIT */
2424
284f4730
JB
2425/* Given a struct input_event, build the lisp event which represents
2426 it. If EVENT is 0, build a mouse movement event from the mouse
88cb0656
JB
2427 movement buffer, which should have a movement event in it.
2428
2429 Note that events must be passed to this function in the order they
2430 are received; this function stores the location of button presses
2431 in order to build drag events when the button is released. */
284f4730
JB
2432
2433static Lisp_Object
2434make_lispy_event (event)
2435 struct input_event *event;
2436{
79a7046c
RS
2437 int i;
2438
284f4730
JB
2439#ifdef SWITCH_ENUM_BUG
2440 switch ((int) event->kind)
2441#else
2442 switch (event->kind)
2443#endif
2444 {
284f4730
JB
2445 /* A simple keystroke. */
2446 case ascii_keystroke:
86e5706b 2447 {
e9bf89a0 2448 int c = event->code & 0377;
5a1c6df8
JB
2449 /* Turn ASCII characters into control characters
2450 when proper. */
2451 if (event->modifiers & ctrl_modifier)
d205953b
JB
2452 c = make_ctrl_char (c);
2453
2454 /* Add in the other modifier bits. We took care of ctrl_modifier
2455 just above, and the shift key was taken care of by the X code,
2456 and applied to control characters by make_ctrl_char. */
86e5706b
RS
2457 c |= (event->modifiers
2458 & (meta_modifier | alt_modifier
2459 | hyper_modifier | super_modifier));
559f9d04 2460 button_down_time = 0;
86e5706b
RS
2461 return c;
2462 }
284f4730
JB
2463
2464 /* A function key. The symbol may need to have modifier prefixes
2465 tacked onto it. */
2466 case non_ascii_keystroke:
559f9d04 2467 button_down_time = 0;
e9bf89a0
RS
2468
2469 for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
2470 if (event->code == lispy_accent_codes[i])
2471 return modify_event_symbol (i,
2472 event->modifiers,
80e4aa30 2473 Qfunction_key, Qnil,
e9bf89a0
RS
2474 lispy_accent_keys, &accent_key_syms,
2475 (sizeof (lispy_accent_keys)
2476 / sizeof (lispy_accent_keys[0])));
2477
270a208f 2478 /* Handle system-specific keysyms. */
80e4aa30
RS
2479 if (event->code & (1 << 28))
2480 {
2481 /* We need to use an alist rather than a vector as the cache
2482 since we can't make a vector long enuf. */
270a208f
RS
2483 if (NILP (system_key_syms))
2484 system_key_syms = Fcons (Qnil, Qnil);
80e4aa30
RS
2485 return modify_event_symbol (event->code & 0xffffff,
2486 event->modifiers,
270a208f
RS
2487 Qfunction_key, Vsystem_key_alist,
2488 0, &system_key_syms, 0xffffff);
80e4aa30
RS
2489 }
2490
e9bf89a0
RS
2491 return modify_event_symbol (event->code - 0xff00,
2492 event->modifiers,
80e4aa30 2493 Qfunction_key, Qnil,
284f4730
JB
2494 lispy_function_keys, &func_key_syms,
2495 (sizeof (lispy_function_keys)
2496 / sizeof (lispy_function_keys[0])));
2497 break;
2498
5846638c 2499#if defined(MULTI_FRAME) || defined(HAVE_MOUSE)
88cb0656
JB
2500 /* A mouse click. Figure out where it is, decide whether it's
2501 a press, click or drag, and build the appropriate structure. */
284f4730 2502 case mouse_click:
3c370943 2503 case scroll_bar_click:
284f4730 2504 {
e9bf89a0 2505 int button = event->code;
559f9d04 2506 int is_double;
7b4aedb9 2507 Lisp_Object position;
dbc4e1c1
JB
2508 Lisp_Object *start_pos_ptr;
2509 Lisp_Object start_pos;
284f4730 2510
7b4aedb9 2511 if (button < 0 || button >= NUM_MOUSE_BUTTONS)
88cb0656
JB
2512 abort ();
2513
7b4aedb9
JB
2514 /* Build the position as appropriate for this mouse click. */
2515 if (event->kind == mouse_click)
284f4730 2516 {
7b4aedb9 2517 int part;
598a9fa7 2518 FRAME_PTR f = XFRAME (event->frame_or_window);
0aafc975 2519 Lisp_Object window;
7b4aedb9 2520 Lisp_Object posn;
9e20143a
RS
2521 int row, column;
2522
2523 pixel_to_glyph_coords (f, XINT (event->x), XINT (event->y),
2524 &column, &row, 0, 0);
7b4aedb9 2525
bb936752
FP
2526#ifdef USE_X_TOOLKIT
2527 if (FRAME_EXTERNAL_MENU_BAR (f) && XINT (event->y) == -1)
7b260679 2528#else
9e20143a 2529 if (row < FRAME_MENU_BAR_LINES (f))
7b260679 2530#endif
bb936752 2531 {
b7c49376 2532 Lisp_Object items, item;
0aafc975 2533
7b260679 2534#ifdef USE_X_TOOLKIT
bb936752
FP
2535 /* The click happened in the menubar.
2536 Look for the menu item selected. */
b7c49376 2537 item = map_event_to_object (event, f);
0aafc975 2538
bb936752
FP
2539 XFASTINT (event->y) = 1;
2540#else /* not USE_X_TOOLKIT */
5ec75a55 2541 int hpos;
b7c49376 2542 int i;
0aafc975 2543
f2ae6b3f 2544 item = Qnil;
5ec75a55 2545 items = FRAME_MENU_BAR_ITEMS (f);
b7c49376 2546 for (i = 0; i < XVECTOR (items)->size; i += 3)
5ec75a55
RS
2547 {
2548 Lisp_Object pos, string;
b7c49376
RS
2549 string = XVECTOR (items)->contents[i + 1];
2550 pos = XVECTOR (items)->contents[i + 2];
2551 if (NILP (string))
2552 break;
9e20143a
RS
2553 if (column >= XINT (pos)
2554 && column < XINT (pos) + XSTRING (string)->size)
b7c49376
RS
2555 {
2556 item = XVECTOR (items)->contents[i];
2557 break;
2558 }
5ec75a55 2559 }
bb936752 2560#endif /* not USE_X_TOOLKIT */
9e20143a 2561
5ec75a55
RS
2562 position
2563 = Fcons (event->frame_or_window,
2564 Fcons (Qmenu_bar,
2565 Fcons (Fcons (event->x, event->y),
2566 Fcons (make_number (event->timestamp),
2567 Qnil))));
2568
b7c49376 2569 return Fcons (item, Fcons (position, Qnil));
5ec75a55 2570 }
0aafc975 2571
9e20143a 2572 window = window_from_coordinates (f, column, row, &part);
0aafc975
RS
2573
2574 if (XTYPE (window) != Lisp_Window)
7b4aedb9 2575 posn = Qnil;
284f4730 2576 else
7b4aedb9 2577 {
9e20143a
RS
2578 int pixcolumn, pixrow;
2579 column -= XINT (XWINDOW (window)->left);
2580 row -= XINT (XWINDOW (window)->top);
2581 glyph_to_pixel_coords (f, column, row, &pixcolumn, &pixrow);
2582 XSETINT (event->x, pixcolumn);
2583 XSETINT (event->y, pixrow);
dbc4e1c1 2584
7b4aedb9
JB
2585 if (part == 1)
2586 posn = Qmode_line;
2587 else if (part == 2)
2588 posn = Qvertical_line;
2589 else
dbc4e1c1
JB
2590 XSET (posn, Lisp_Int,
2591 buffer_posn_from_coords (XWINDOW (window),
9e20143a 2592 column, row));
7b4aedb9
JB
2593 }
2594
5ec75a55
RS
2595 position
2596 = Fcons (window,
2597 Fcons (posn,
2598 Fcons (Fcons (event->x, event->y),
2599 Fcons (make_number (event->timestamp),
2600 Qnil))));
284f4730 2601 }
7b4aedb9 2602 else
88cb0656 2603 {
9e20143a
RS
2604 Lisp_Object window;
2605 Lisp_Object portion_whole;
2606 Lisp_Object part;
2607
2608 window = event->frame_or_window;
2609 portion_whole = Fcons (event->x, event->y);
2610 part = *scroll_bar_parts[(int) event->part];
7b4aedb9
JB
2611
2612 position =
2613 Fcons (window,
3c370943 2614 Fcons (Qvertical_scroll_bar,
7b4aedb9
JB
2615 Fcons (portion_whole,
2616 Fcons (make_number (event->timestamp),
9e20143a 2617 Fcons (part, Qnil)))));
88cb0656
JB
2618 }
2619
dbc4e1c1
JB
2620 start_pos_ptr = &XVECTOR (button_down_location)->contents[button];
2621
2622 start_pos = *start_pos_ptr;
2623 *start_pos_ptr = Qnil;
7b4aedb9 2624
559f9d04
RS
2625 is_double = (button == last_mouse_button
2626 && XINT (event->x) == last_mouse_x
2627 && XINT (event->y) == last_mouse_y
2628 && button_down_time != 0
2629 && (EQ (Vdouble_click_time, Qt)
2630 || (INTEGERP (Vdouble_click_time)
2631 && ((int)(event->timestamp - button_down_time)
2632 < XINT (Vdouble_click_time)))));
2633 last_mouse_button = button;
2634 last_mouse_x = XINT (event->x);
2635 last_mouse_y = XINT (event->y);
2636
7b4aedb9
JB
2637 /* If this is a button press, squirrel away the location, so
2638 we can decide later whether it was a click or a drag. */
2639 if (event->modifiers & down_modifier)
559f9d04
RS
2640 {
2641 if (is_double)
2642 {
2643 double_click_count++;
2644 event->modifiers |= ((double_click_count > 2)
2645 ? triple_modifier
2646 : double_modifier);
2647 }
2648 else
2649 double_click_count = 1;
2650 button_down_time = event->timestamp;
2651 *start_pos_ptr = Fcopy_alist (position);
2652 }
7b4aedb9 2653
88cb0656 2654 /* Now we're releasing a button - check the co-ordinates to
7b4aedb9 2655 see if this was a click or a drag. */
88cb0656
JB
2656 else if (event->modifiers & up_modifier)
2657 {
48e416d4
RS
2658 /* If we did not see a down before this up,
2659 ignore the up. Probably this happened because
2660 the down event chose a menu item.
2661 It would be an annoyance to treat the release
2662 of the button that chose the menu item
2663 as a separate event. */
2664
2665 if (XTYPE (start_pos) != Lisp_Cons)
2666 return Qnil;
2667
88cb0656 2668 event->modifiers &= ~up_modifier;
48e416d4 2669#if 0 /* Formerly we treated an up with no down as a click event. */
dbc4e1c1
JB
2670 if (XTYPE (start_pos) != Lisp_Cons)
2671 event->modifiers |= click_modifier;
2672 else
48e416d4 2673#endif
dbc4e1c1
JB
2674 {
2675 /* The third element of every position should be the (x,y)
2676 pair. */
9b8eb840 2677 Lisp_Object down;
dbc4e1c1 2678
9b8eb840 2679 down = Fnth (make_number (2), start_pos);
fbcd35bd
JB
2680 if (EQ (event->x, XCONS (down)->car)
2681 && EQ (event->y, XCONS (down)->cdr))
2682 {
559f9d04
RS
2683 if (is_double && double_click_count > 1)
2684 event->modifiers |= ((double_click_count > 2)
2685 ? triple_modifier
2686 : double_modifier);
fbcd35bd 2687 else
559f9d04 2688 event->modifiers |= click_modifier;
fbcd35bd
JB
2689 }
2690 else
2691 {
559f9d04 2692 button_down_time = 0;
fbcd35bd
JB
2693 event->modifiers |= drag_modifier;
2694 }
dbc4e1c1 2695 }
88cb0656
JB
2696 }
2697 else
2698 /* Every mouse event should either have the down_modifier or
7b4aedb9 2699 the up_modifier set. */
88cb0656
JB
2700 abort ();
2701
88cb0656 2702 {
7b4aedb9 2703 /* Get the symbol we should use for the mouse click. */
9b8eb840
KH
2704 Lisp_Object head;
2705
2706 head = modify_event_symbol (button,
2707 event->modifiers,
2708 Qmouse_click, Qnil,
2709 lispy_mouse_names, &mouse_syms,
2710 (sizeof (lispy_mouse_names)
2711 / sizeof (lispy_mouse_names[0])));
88cb0656 2712 if (event->modifiers & drag_modifier)
dbc4e1c1
JB
2713 return Fcons (head,
2714 Fcons (start_pos,
2715 Fcons (position,
2716 Qnil)));
fbcd35bd
JB
2717 else if (event->modifiers & (double_modifier | triple_modifier))
2718 return Fcons (head,
2719 Fcons (position,
2720 Fcons (make_number (double_click_count),
2721 Qnil)));
88cb0656
JB
2722 else
2723 return Fcons (head,
7b4aedb9 2724 Fcons (position,
88cb0656
JB
2725 Qnil));
2726 }
284f4730 2727 }
5846638c 2728#endif /* MULTI_FRAME or HAVE_MOUSE */
284f4730 2729
284f4730
JB
2730 /* The 'kind' field of the event is something we don't recognize. */
2731 default:
48e416d4 2732 abort ();
284f4730
JB
2733 }
2734}
2735
6cbff1cb
RS
2736#ifdef MULTI_FRAME
2737
284f4730 2738static Lisp_Object
7b4aedb9 2739make_lispy_movement (frame, bar_window, part, x, y, time)
ff11dfa1 2740 FRAME_PTR frame;
7b4aedb9 2741 Lisp_Object bar_window;
3c370943 2742 enum scroll_bar_part part;
284f4730 2743 Lisp_Object x, y;
e5d77022 2744 unsigned long time;
284f4730 2745{
3c370943 2746 /* Is it a scroll bar movement? */
7b4aedb9 2747 if (frame && ! NILP (bar_window))
4bb994d1 2748 {
9b8eb840 2749 Lisp_Object part_sym;
4bb994d1 2750
9b8eb840 2751 part_sym = *scroll_bar_parts[(int) part];
3c370943 2752 return Fcons (Qscroll_bar_movement,
7b4aedb9 2753 (Fcons (Fcons (bar_window,
3c370943 2754 Fcons (Qvertical_scroll_bar,
4bb994d1
JB
2755 Fcons (Fcons (x, y),
2756 Fcons (make_number (time),
cb5df6ae 2757 Fcons (part_sym,
4bb994d1
JB
2758 Qnil))))),
2759 Qnil)));
2760 }
2761
2762 /* Or is it an ordinary mouse movement? */
284f4730
JB
2763 else
2764 {
4bb994d1 2765 int area;
9e20143a 2766 Lisp_Object window;
4bb994d1 2767 Lisp_Object posn;
9e20143a
RS
2768 int column, row;
2769
f02256ef 2770 pixel_to_glyph_coords (frame, XINT (x), XINT (y), &column, &row, 0, 1);
9e20143a
RS
2771
2772 if (frame)
2773 window = window_from_coordinates (frame, column, row, &area);
2774 else
2775 window = Qnil;
4bb994d1
JB
2776
2777 if (XTYPE (window) == Lisp_Window)
2778 {
9e20143a
RS
2779 int pixcolumn, pixrow;
2780 column -= XINT (XWINDOW (window)->left);
2781 row -= XINT (XWINDOW (window)->top);
2782 glyph_to_pixel_coords (frame, column, row, &pixcolumn, &pixrow);
2783 XSETINT (x, pixcolumn);
2784 XSETINT (y, pixrow);
4bb994d1
JB
2785
2786 if (area == 1)
2787 posn = Qmode_line;
2788 else if (area == 2)
2789 posn = Qvertical_line;
2790 else
2791 XSET (posn, Lisp_Int,
9e20143a 2792 buffer_posn_from_coords (XWINDOW (window), column, row));
4bb994d1 2793 }
e9bf89a0
RS
2794 else if (frame != 0)
2795 {
2796 XSET (window, Lisp_Frame, frame);
2797 posn = Qnil;
2798 }
284f4730 2799 else
4bb994d1
JB
2800 {
2801 window = Qnil;
2802 posn = Qnil;
f76b81d6
JB
2803 XFASTINT (x) = 0;
2804 XFASTINT (y) = 0;
4bb994d1 2805 }
284f4730 2806
4bb994d1
JB
2807 return Fcons (Qmouse_movement,
2808 Fcons (Fcons (window,
2809 Fcons (posn,
2810 Fcons (Fcons (x, y),
2811 Fcons (make_number (time),
2812 Qnil)))),
2813 Qnil));
2814 }
284f4730
JB
2815}
2816
6cbff1cb
RS
2817#endif /* MULTI_FRAME */
2818
cd21b839
JB
2819/* Construct a switch frame event. */
2820static Lisp_Object
2821make_lispy_switch_frame (frame)
2822 Lisp_Object frame;
2823{
2824 return Fcons (Qswitch_frame, Fcons (frame, Qnil));
2825}
0a7f1fc0
JB
2826\f
2827/* Manipulating modifiers. */
284f4730 2828
0a7f1fc0 2829/* Parse the name of SYMBOL, and return the set of modifiers it contains.
284f4730 2830
0a7f1fc0
JB
2831 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
2832 SYMBOL's name of the end of the modifiers; the string from this
2833 position is the unmodified symbol name.
284f4730 2834
0a7f1fc0
JB
2835 This doesn't use any caches. */
2836static int
2837parse_modifiers_uncached (symbol, modifier_end)
284f4730 2838 Lisp_Object symbol;
0a7f1fc0 2839 int *modifier_end;
284f4730
JB
2840{
2841 struct Lisp_String *name;
2842 int i;
2843 int modifiers;
284f4730
JB
2844
2845 CHECK_SYMBOL (symbol, 1);
2846
2847 modifiers = 0;
2848 name = XSYMBOL (symbol)->name;
2849
284f4730 2850
0a7f1fc0 2851 for (i = 0; i+2 <= name->size; )
284f4730
JB
2852 switch (name->data[i])
2853 {
0a7f1fc0
JB
2854#define SINGLE_LETTER_MOD(bit) \
2855 if (name->data[i+1] != '-') \
2856 goto no_more_modifiers; \
2857 modifiers |= bit; \
fce33686 2858 i += 2;
0a7f1fc0
JB
2859
2860 case 'A':
2861 SINGLE_LETTER_MOD (alt_modifier);
284f4730
JB
2862 break;
2863
2864 case 'C':
0a7f1fc0 2865 SINGLE_LETTER_MOD (ctrl_modifier);
fce33686
JB
2866 break;
2867
2868 case 'H':
0a7f1fc0 2869 SINGLE_LETTER_MOD (hyper_modifier);
fce33686
JB
2870 break;
2871
2872 case 'M':
0a7f1fc0 2873 SINGLE_LETTER_MOD (meta_modifier);
284f4730
JB
2874 break;
2875
2876 case 'S':
0a7f1fc0 2877 SINGLE_LETTER_MOD (shift_modifier);
fce33686
JB
2878 break;
2879
2880 case 's':
86e5706b 2881 SINGLE_LETTER_MOD (super_modifier);
284f4730
JB
2882 break;
2883
fce33686
JB
2884 case 'd':
2885 if (i + 5 > name->size)
2886 goto no_more_modifiers;
2887 if (! strncmp (name->data + i, "drag-", 5))
2888 {
fce33686
JB
2889 modifiers |= drag_modifier;
2890 i += 5;
2891 }
2892 else if (! strncmp (name->data + i, "down-", 5))
2893 {
fce33686
JB
2894 modifiers |= down_modifier;
2895 i += 5;
2896 }
fbcd35bd
JB
2897 else if (i + 7 <= name->size
2898 && ! strncmp (name->data + i, "double-", 7))
2899 {
2900 modifiers |= double_modifier;
2901 i += 7;
2902 }
2903 else
2904 goto no_more_modifiers;
2905 break;
2906
2907 case 't':
2908 if (i + 7 > name->size)
2909 goto no_more_modifiers;
2910 if (! strncmp (name->data + i, "triple-", 7))
2911 {
2912 modifiers |= triple_modifier;
2913 i += 7;
2914 }
fce33686
JB
2915 else
2916 goto no_more_modifiers;
284f4730
JB
2917 break;
2918
2919 default:
2920 goto no_more_modifiers;
0a7f1fc0
JB
2921
2922#undef SINGLE_LETTER_MOD
284f4730
JB
2923 }
2924 no_more_modifiers:
2925
0a7f1fc0 2926 /* Should we include the `click' modifier? */
fbcd35bd
JB
2927 if (! (modifiers & (down_modifier | drag_modifier
2928 | double_modifier | triple_modifier))
0a7f1fc0 2929 && i + 7 == name->size
4bb994d1 2930 && strncmp (name->data + i, "mouse-", 6) == 0
6569cc8d 2931 && ('0' <= name->data[i + 6] && name->data[i + 6] <= '9'))
0a7f1fc0
JB
2932 modifiers |= click_modifier;
2933
2934 if (modifier_end)
2935 *modifier_end = i;
2936
2937 return modifiers;
2938}
2939
2940
2941/* Return a symbol whose name is the modifier prefixes for MODIFIERS
2942 prepended to the string BASE[0..BASE_LEN-1].
2943 This doesn't use any caches. */
2944static Lisp_Object
2945apply_modifiers_uncached (modifiers, base, base_len)
2946 int modifiers;
2947 char *base;
2948 int base_len;
2949{
2950 /* Since BASE could contain nulls, we can't use intern here; we have
2951 to use Fintern, which expects a genuine Lisp_String, and keeps a
2952 reference to it. */
2953 char *new_mods =
fbcd35bd 2954 (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
0a7f1fc0 2955 int mod_len;
284f4730 2956
284f4730 2957 {
0a7f1fc0
JB
2958 char *p = new_mods;
2959
2960 /* Only the event queue may use the `up' modifier; it should always
2961 be turned into a click or drag event before presented to lisp code. */
2962 if (modifiers & up_modifier)
2963 abort ();
2964
2965 if (modifiers & alt_modifier) { *p++ = 'A'; *p++ = '-'; }
2966 if (modifiers & ctrl_modifier) { *p++ = 'C'; *p++ = '-'; }
2967 if (modifiers & hyper_modifier) { *p++ = 'H'; *p++ = '-'; }
2968 if (modifiers & meta_modifier) { *p++ = 'M'; *p++ = '-'; }
2969 if (modifiers & shift_modifier) { *p++ = 'S'; *p++ = '-'; }
86e5706b 2970 if (modifiers & super_modifier) { *p++ = 's'; *p++ = '-'; }
fbcd35bd
JB
2971 if (modifiers & double_modifier) { strcpy (p, "double-"); p += 7; }
2972 if (modifiers & triple_modifier) { strcpy (p, "triple-"); p += 7; }
559f9d04
RS
2973 if (modifiers & down_modifier) { strcpy (p, "down-"); p += 5; }
2974 if (modifiers & drag_modifier) { strcpy (p, "drag-"); p += 5; }
0a7f1fc0
JB
2975 /* The click modifier is denoted by the absence of other modifiers. */
2976
2977 *p = '\0';
2978
2979 mod_len = p - new_mods;
2980 }
284f4730 2981
0a7f1fc0 2982 {
9b8eb840 2983 Lisp_Object new_name;
0a7f1fc0 2984
9b8eb840 2985 new_name = make_uninit_string (mod_len + base_len);
0a7f1fc0
JB
2986 bcopy (new_mods, XSTRING (new_name)->data, mod_len);
2987 bcopy (base, XSTRING (new_name)->data + mod_len, base_len);
284f4730
JB
2988
2989 return Fintern (new_name, Qnil);
2990 }
2991}
2992
2993
0a7f1fc0
JB
2994static char *modifier_names[] =
2995{
fbcd35bd 2996 "up", "down", "drag", "click", "double", "triple", 0, 0,
1dfdf9e2 2997 0, 0, 0, 0, 0, 0, 0, 0,
86e5706b 2998 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
0a7f1fc0 2999};
80645119 3000#define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
0a7f1fc0
JB
3001
3002static Lisp_Object modifier_symbols;
3003
3004/* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
3005static Lisp_Object
3006lispy_modifier_list (modifiers)
3007 int modifiers;
3008{
3009 Lisp_Object modifier_list;
3010 int i;
3011
3012 modifier_list = Qnil;
80645119 3013 for (i = 0; (1<<i) <= modifiers && i < NUM_MOD_NAMES; i++)
0a7f1fc0 3014 if (modifiers & (1<<i))
80645119
JB
3015 modifier_list = Fcons (XVECTOR (modifier_symbols)->contents[i],
3016 modifier_list);
0a7f1fc0
JB
3017
3018 return modifier_list;
3019}
3020
3021
3022/* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
3023 where UNMODIFIED is the unmodified form of SYMBOL,
3024 MASK is the set of modifiers present in SYMBOL's name.
3025 This is similar to parse_modifiers_uncached, but uses the cache in
3026 SYMBOL's Qevent_symbol_element_mask property, and maintains the
3027 Qevent_symbol_elements property. */
3028static Lisp_Object
3029parse_modifiers (symbol)
3030 Lisp_Object symbol;
3031{
9b8eb840 3032 Lisp_Object elements;
0a7f1fc0 3033
9b8eb840 3034 elements = Fget (symbol, Qevent_symbol_element_mask);
0a7f1fc0
JB
3035 if (CONSP (elements))
3036 return elements;
3037 else
3038 {
3039 int end;
3040 int modifiers = parse_modifiers_uncached (symbol, &end);
9b8eb840 3041 Lisp_Object unmodified;
0a7f1fc0
JB
3042 Lisp_Object mask;
3043
9b8eb840
KH
3044 unmodified = Fintern (make_string (XSYMBOL (symbol)->name->data + end,
3045 XSYMBOL (symbol)->name->size - end),
3046 Qnil);
3047
734fef94
JB
3048 if (modifiers & ~((1<<VALBITS) - 1))
3049 abort ();
0a7f1fc0
JB
3050 XFASTINT (mask) = modifiers;
3051 elements = Fcons (unmodified, Fcons (mask, Qnil));
3052
3053 /* Cache the parsing results on SYMBOL. */
3054 Fput (symbol, Qevent_symbol_element_mask,
3055 elements);
3056 Fput (symbol, Qevent_symbol_elements,
3057 Fcons (unmodified, lispy_modifier_list (modifiers)));
3058
3059 /* Since we know that SYMBOL is modifiers applied to unmodified,
3060 it would be nice to put that in unmodified's cache.
3061 But we can't, since we're not sure that parse_modifiers is
3062 canonical. */
3063
3064 return elements;
3065 }
3066}
3067
3068/* Apply the modifiers MODIFIERS to the symbol BASE.
3069 BASE must be unmodified.
3070
3071 This is like apply_modifiers_uncached, but uses BASE's
3072 Qmodifier_cache property, if present. It also builds
cd21b839
JB
3073 Qevent_symbol_elements properties, since it has that info anyway.
3074
3075 apply_modifiers copies the value of BASE's Qevent_kind property to
3076 the modified symbol. */
0a7f1fc0
JB
3077static Lisp_Object
3078apply_modifiers (modifiers, base)
3079 int modifiers;
3080 Lisp_Object base;
3081{
7b4aedb9 3082 Lisp_Object cache, index, entry, new_symbol;
0a7f1fc0 3083
80645119
JB
3084 /* Mask out upper bits. We don't know where this value's been. */
3085 modifiers &= (1<<VALBITS) - 1;
3086
0a7f1fc0 3087 /* The click modifier never figures into cache indices. */
0a7f1fc0 3088 cache = Fget (base, Qmodifier_cache);
cd21b839 3089 XFASTINT (index) = (modifiers & ~click_modifier);
0a7f1fc0
JB
3090 entry = Fassq (index, cache);
3091
3092 if (CONSP (entry))
7b4aedb9
JB
3093 new_symbol = XCONS (entry)->cdr;
3094 else
3095 {
3096 /* We have to create the symbol ourselves. */
3097 new_symbol = apply_modifiers_uncached (modifiers,
3098 XSYMBOL (base)->name->data,
3099 XSYMBOL (base)->name->size);
3100
3101 /* Add the new symbol to the base's cache. */
3102 entry = Fcons (index, new_symbol);
3103 Fput (base, Qmodifier_cache, Fcons (entry, cache));
3104
3105 /* We have the parsing info now for free, so add it to the caches. */
3106 XFASTINT (index) = modifiers;
3107 Fput (new_symbol, Qevent_symbol_element_mask,
3108 Fcons (base, Fcons (index, Qnil)));
3109 Fput (new_symbol, Qevent_symbol_elements,
3110 Fcons (base, lispy_modifier_list (modifiers)));
3111 }
0a7f1fc0 3112
7b4aedb9
JB
3113 /* Make sure this symbol is of the same kind as BASE.
3114
3115 You'd think we could just set this once and for all when we
3116 intern the symbol above, but reorder_modifiers may call us when
3117 BASE's property isn't set right; we can't assume that just
80645119
JB
3118 because it has a Qmodifier_cache property it must have its
3119 Qevent_kind set right as well. */
7b4aedb9
JB
3120 if (NILP (Fget (new_symbol, Qevent_kind)))
3121 {
9b8eb840 3122 Lisp_Object kind;
7b4aedb9 3123
9b8eb840 3124 kind = Fget (base, Qevent_kind);
7b4aedb9
JB
3125 if (! NILP (kind))
3126 Fput (new_symbol, Qevent_kind, kind);
3127 }
3128
3129 return new_symbol;
0a7f1fc0
JB
3130}
3131
3132
3133/* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
3134 return a symbol with the modifiers placed in the canonical order.
3135 Canonical order is alphabetical, except for down and drag, which
3136 always come last. The 'click' modifier is never written out.
3137
3138 Fdefine_key calls this to make sure that (for example) C-M-foo
3139 and M-C-foo end up being equivalent in the keymap. */
3140
3141Lisp_Object
3142reorder_modifiers (symbol)
3143 Lisp_Object symbol;
3144{
3145 /* It's hopefully okay to write the code this way, since everything
3146 will soon be in caches, and no consing will be done at all. */
9b8eb840 3147 Lisp_Object parsed;
0a7f1fc0 3148
9b8eb840 3149 parsed = parse_modifiers (symbol);
0a7f1fc0
JB
3150 return apply_modifiers (XCONS (XCONS (parsed)->cdr)->car,
3151 XCONS (parsed)->car);
3152}
3153
3154
284f4730
JB
3155/* For handling events, we often want to produce a symbol whose name
3156 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
3157 to some base, like the name of a function key or mouse button.
3158 modify_event_symbol produces symbols of this sort.
3159
3160 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
3161 is the name of the i'th symbol. TABLE_SIZE is the number of elements
3162 in the table.
3163
80e4aa30
RS
3164 Alternatively, NAME_ALIST is an alist mapping codes into symbol names.
3165 NAME_ALIST is used if it is non-nil; otherwise NAME_TABLE is used.
3166
284f4730
JB
3167 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
3168 persist between calls to modify_event_symbol that it can use to
3169 store a cache of the symbols it's generated for this NAME_TABLE
80e4aa30 3170 before. The object stored there may be a vector or an alist.
284f4730
JB
3171
3172 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
3173
3174 MODIFIERS is a set of modifier bits (as given in struct input_events)
3175 whose prefixes should be applied to the symbol name.
3176
3177 SYMBOL_KIND is the value to be placed in the event_kind property of
88cb0656
JB
3178 the returned symbol.
3179
3180 The symbols we create are supposed to have an
eb8c3be9 3181 `event-symbol-elements' property, which lists the modifiers present
88cb0656
JB
3182 in the symbol's name. */
3183
284f4730 3184static Lisp_Object
80e4aa30
RS
3185modify_event_symbol (symbol_num, modifiers, symbol_kind, name_alist,
3186 name_table, symbol_table, table_size)
284f4730
JB
3187 int symbol_num;
3188 unsigned modifiers;
3189 Lisp_Object symbol_kind;
80e4aa30 3190 Lisp_Object name_alist;
284f4730
JB
3191 char **name_table;
3192 Lisp_Object *symbol_table;
3193 int table_size;
3194{
80e4aa30
RS
3195 Lisp_Object value;
3196 Lisp_Object symbol_int;
3197
3198 XSET (symbol_int, Lisp_Int, symbol_num);
284f4730
JB
3199
3200 /* Is this a request for a valid symbol? */
88cb0656 3201 if (symbol_num < 0 || symbol_num >= table_size)
284f4730
JB
3202 abort ();
3203
80e4aa30
RS
3204 if (CONSP (*symbol_table))
3205 value = Fcdr (assq_no_quit (symbol_int, *symbol_table));
3206
0a7f1fc0 3207 /* If *symbol_table doesn't seem to be initialized properly, fix that.
88cb0656 3208 *symbol_table should be a lisp vector TABLE_SIZE elements long,
4bb994d1
JB
3209 where the Nth element is the symbol for NAME_TABLE[N], or nil if
3210 we've never used that symbol before. */
80e4aa30 3211 else
88cb0656 3212 {
80e4aa30
RS
3213 if (! VECTORP (*symbol_table)
3214 || XVECTOR (*symbol_table)->size != table_size)
3215 {
3216 Lisp_Object size;
0a7f1fc0 3217
80e4aa30
RS
3218 XFASTINT (size) = table_size;
3219 *symbol_table = Fmake_vector (size, Qnil);
3220 }
284f4730 3221
80e4aa30
RS
3222 value = XVECTOR (*symbol_table)->contents[symbol_num];
3223 }
284f4730 3224
0a7f1fc0 3225 /* Have we already used this symbol before? */
80e4aa30 3226 if (NILP (value))
284f4730 3227 {
0a7f1fc0 3228 /* No; let's create it. */
80e4aa30 3229 if (!NILP (name_alist))
b64b4075 3230 value = Fcdr_safe (Fassq (symbol_int, name_alist));
80e4aa30
RS
3231 else if (name_table[symbol_num])
3232 value = intern (name_table[symbol_num]);
b64b4075
RS
3233
3234 if (NILP (value))
d1f50460
RS
3235 {
3236 char buf[20];
3237 sprintf (buf, "key-%d", symbol_num);
80e4aa30 3238 value = intern (buf);
d1f50460 3239 }
0a7f1fc0 3240
80e4aa30
RS
3241 if (CONSP (*symbol_table))
3242 *symbol_table = Fcons (value, *symbol_table);
3243 else
3244 XVECTOR (*symbol_table)->contents[symbol_num] = value;
3245
0a7f1fc0
JB
3246 /* Fill in the cache entries for this symbol; this also
3247 builds the Qevent_symbol_elements property, which the user
3248 cares about. */
80e4aa30
RS
3249 apply_modifiers (modifiers & click_modifier, value);
3250 Fput (value, Qevent_kind, symbol_kind);
284f4730 3251 }
88cb0656 3252
0a7f1fc0 3253 /* Apply modifiers to that symbol. */
80e4aa30 3254 return apply_modifiers (modifiers, value);
284f4730 3255}
0a7f1fc0 3256
284f4730 3257\f
284f4730
JB
3258/* Store into *addr a value nonzero if terminal input chars are available.
3259 Serves the purpose of ioctl (0, FIONREAD, addr)
3260 but works even if FIONREAD does not exist.
3261 (In fact, this may actually read some input.) */
3262
3263static void
3264get_input_pending (addr)
3265 int *addr;
3266{
3267 /* First of all, have we already counted some input? */
3268 *addr = !NILP (Vquit_flag) || readable_events ();
3269
3270 /* If input is being read as it arrives, and we have none, there is none. */
3271 if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
3272 return;
3273
3274 /* Try to read some input and see how much we get. */
3275 gobble_input (0);
3276 *addr = !NILP (Vquit_flag) || readable_events ();
3277}
3278
3279/* Interface to read_avail_input, blocking SIGIO if necessary. */
3280
3281int
3282gobble_input (expected)
3283 int expected;
3284{
3285#ifndef VMS
3286#ifdef SIGIO
3287 if (interrupt_input)
3288 {
32676c08 3289 SIGMASKTYPE mask;
e065a56e 3290 mask = sigblockx (SIGIO);
284f4730 3291 read_avail_input (expected);
e065a56e 3292 sigsetmask (mask);
284f4730
JB
3293 }
3294 else
3295#endif
3296 read_avail_input (expected);
3297#endif
3298}
a8015ab5 3299
241ceaf7
RS
3300/* Put a buffer_switch_event in the buffer
3301 so that read_key_sequence will notice the new current buffer. */
3302
a8015ab5
KH
3303record_asynch_buffer_change ()
3304{
3305 struct input_event event;
3306 event.kind = buffer_switch_event;
3307 event.frame_or_window = Qnil;
241ceaf7
RS
3308
3309 /* Make sure no interrupt happens while storing the event. */
3310#ifdef SIGIO
3311 if (interrupt_input)
3312 {
3313 SIGMASKTYPE mask;
3314 mask = sigblockx (SIGIO);
3315 kbd_buffer_store_event (&event);
3316 sigsetmask (mask);
3317 }
3318 else
3319#endif
3320 {
3321 stop_polling ();
3322 kbd_buffer_store_event (&event);
3323 start_polling ();
3324 }
a8015ab5 3325}
284f4730
JB
3326\f
3327#ifndef VMS
3328
3329/* Read any terminal input already buffered up by the system
3330 into the kbd_buffer, but do not wait.
3331
3332 EXPECTED should be nonzero if the caller knows there is some input.
3333
3334 Except on VMS, all input is read by this function.
3335 If interrupt_input is nonzero, this function MUST be called
3336 only when SIGIO is blocked.
3337
3338 Returns the number of keyboard chars read, or -1 meaning
3339 this is a bad time to try to read input. */
3340
3341static int
3342read_avail_input (expected)
3343 int expected;
3344{
3345 struct input_event buf[KBD_BUFFER_SIZE];
3346 register int i;
3347 int nread;
3348
3349 if (read_socket_hook)
3350 /* No need for FIONREAD or fcntl; just say don't wait. */
3351 nread = (*read_socket_hook) (0, buf, KBD_BUFFER_SIZE, expected, expected);
3352 else
3353 {
17270835
RS
3354 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
3355 the kbd_buffer can really hold. That may prevent loss
3356 of characters on some systems when input is stuffed at us. */
3357 unsigned char cbuf[KBD_BUFFER_SIZE - 1];
58788063 3358 int n_to_read;
284f4730 3359
58788063 3360 /* Determine how many characters we should *try* to read. */
80e4aa30 3361#ifdef MSDOS
58788063
RS
3362 n_to_read = dos_keysns ();
3363 if (n_to_read == 0)
3364 return 0;
c3a2738c 3365#else /* not MSDOS */
284f4730
JB
3366#ifdef FIONREAD
3367 /* Find out how much input is available. */
58788063 3368 if (ioctl (0, FIONREAD, &n_to_read) < 0)
284f4730
JB
3369 /* Formerly simply reported no input, but that sometimes led to
3370 a failure of Emacs to terminate.
3371 SIGHUP seems appropriate if we can't reach the terminal. */
e4535288
RS
3372 /* ??? Is it really right to send the signal just to this process
3373 rather than to the whole process group?
3374 Perhaps on systems with FIONREAD Emacs is alone in its group. */
284f4730 3375 kill (getpid (), SIGHUP);
58788063 3376 if (n_to_read == 0)
284f4730 3377 return 0;
58788063
RS
3378 if (n_to_read > sizeof cbuf)
3379 n_to_read = sizeof cbuf;
284f4730 3380#else /* no FIONREAD */
482952ef 3381#if defined(USG) || defined(DGUX)
284f4730 3382 /* Read some input if available, but don't wait. */
58788063 3383 n_to_read = sizeof cbuf;
284f4730
JB
3384 fcntl (fileno (stdin), F_SETFL, O_NDELAY);
3385#else
3386 you lose;
3387#endif
3388#endif
80e4aa30 3389#endif /* not MSDOS */
284f4730 3390
58788063
RS
3391 /* Now read; for one reason or another, this will not block.
3392 NREAD is set to the number of chars read. */
9134775b 3393 do
284f4730 3394 {
80e4aa30
RS
3395#ifdef MSDOS
3396 cbuf[0] = dos_keyread();
3397 nread = 1;
3398#else
58788063 3399 nread = read (fileno (stdin), cbuf, n_to_read);
80e4aa30 3400#endif
762f2b92 3401#if defined (AIX) && (! defined (aix386) && defined (_BSD))
284f4730
JB
3402 /* The kernel sometimes fails to deliver SIGHUP for ptys.
3403 This looks incorrect, but it isn't, because _BSD causes
3404 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
3405 and that causes a value other than 0 when there is no input. */
854f3a54 3406 if (nread == 0)
80e4aa30 3407 kill (0, SIGHUP);
284f4730 3408#endif
9134775b 3409 }
791587ee
KH
3410 while (
3411 /* We used to retry the read if it was interrupted.
3412 But this does the wrong thing when O_NDELAY causes
3413 an EAGAIN error. Does anybody know of a situation
3414 where a retry is actually needed? */
3415#if 0
3416 nread < 0 && (errno == EAGAIN
6aec06f5 3417#ifdef EFAULT
9134775b 3418 || errno == EFAULT
80e4aa30 3419#endif
284f4730 3420#ifdef EBADSLT
9134775b 3421 || errno == EBADSLT
284f4730 3422#endif
791587ee
KH
3423 )
3424#else
3425 0
3426#endif
3427 );
284f4730
JB
3428
3429#ifndef FIONREAD
02c2c53f 3430#if defined (USG) || defined (DGUX)
284f4730 3431 fcntl (fileno (stdin), F_SETFL, 0);
02c2c53f 3432#endif /* USG or DGUX */
284f4730
JB
3433#endif /* no FIONREAD */
3434 for (i = 0; i < nread; i++)
3435 {
3436 buf[i].kind = ascii_keystroke;
86e5706b 3437 buf[i].modifiers = 0;
b04904fb 3438 if (meta_key == 1 && (cbuf[i] & 0x80))
86e5706b 3439 buf[i].modifiers = meta_modifier;
b04904fb
RS
3440 if (meta_key != 2)
3441 cbuf[i] &= ~0x80;
86e5706b 3442
7b4aedb9
JB
3443 XSET (buf[i].code, Lisp_Int, cbuf[i]);
3444#ifdef MULTI_FRAME
3445 XSET (buf[i].frame_or_window, Lisp_Frame, selected_frame);
3446#else
3447 buf[i].frame_or_window = Qnil;
3448#endif
284f4730
JB
3449 }
3450 }
3451
3452 /* Scan the chars for C-g and store them in kbd_buffer. */
3453 for (i = 0; i < nread; i++)
3454 {
3455 kbd_buffer_store_event (&buf[i]);
3456 /* Don't look at input that follows a C-g too closely.
3457 This reduces lossage due to autorepeat on C-g. */
3458 if (buf[i].kind == ascii_keystroke
3459 && XINT(buf[i].code) == quit_char)
3460 break;
3461 }
3462
3463 return nread;
3464}
3465#endif /* not VMS */
3466\f
3467#ifdef SIGIO /* for entire page */
3468/* Note SIGIO has been undef'd if FIONREAD is missing. */
3469
2ce30ea2 3470SIGTYPE
284f4730
JB
3471input_available_signal (signo)
3472 int signo;
3473{
3474 /* Must preserve main program's value of errno. */
3475 int old_errno = errno;
3476#ifdef BSD4_1
3477 extern int select_alarmed;
3478#endif
3479
3480#ifdef USG
3481 /* USG systems forget handlers when they are used;
3482 must reestablish each time */
3483 signal (signo, input_available_signal);
3484#endif /* USG */
3485
3486#ifdef BSD4_1
3487 sigisheld (SIGIO);
3488#endif
3489
ffd56f97
JB
3490 if (input_available_clear_time)
3491 EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
284f4730
JB
3492
3493 while (1)
3494 {
3495 int nread;
3496 nread = read_avail_input (1);
3497 /* -1 means it's not ok to read the input now.
3498 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
3499 0 means there was no keyboard input available. */
3500 if (nread <= 0)
3501 break;
3502
3503#ifdef BSD4_1
3504 select_alarmed = 1; /* Force the select emulator back to life */
3505#endif
3506 }
3507
3508#ifdef BSD4_1
3509 sigfree ();
3510#endif
3511 errno = old_errno;
3512}
3513#endif /* SIGIO */
ad163903
JB
3514
3515/* Send ourselves a SIGIO.
3516
3517 This function exists so that the UNBLOCK_INPUT macro in
3518 blockinput.h can have some way to take care of input we put off
3519 dealing with, without assuming that every file which uses
3520 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
3521void
3522reinvoke_input_signal ()
3523{
3524#ifdef SIGIO
3525 kill (0, SIGIO);
3526#endif
3527}
3528
3529
284f4730
JB
3530\f
3531/* Return the prompt-string of a sparse keymap.
3532 This is the first element which is a string.
3533 Return nil if there is none. */
3534
3535Lisp_Object
3536map_prompt (map)
3537 Lisp_Object map;
3538{
3539 while (CONSP (map))
3540 {
3541 register Lisp_Object tem;
3542 tem = Fcar (map);
3543 if (XTYPE (tem) == Lisp_String)
3544 return tem;
3545 map = Fcdr (map);
3546 }
3547 return Qnil;
3548}
3549
b7c49376
RS
3550static void menu_bar_item ();
3551static void menu_bar_one_keymap ();
3552
3553/* These variables hold the vector under construction within
3554 menu_bar_items and its subroutines, and the current index
3555 for storing into that vector. */
3556static Lisp_Object menu_bar_items_vector;
3557static Lisp_Object menu_bar_items_index;
5ec75a55 3558
b7c49376
RS
3559/* Return a vector of menu items for a menu bar, appropriate
3560 to the current buffer. Each item has three elements in the vector:
f5e09c8b 3561 KEY STRING MAPLIST.
b7c49376
RS
3562
3563 OLD is an old vector we can optionally reuse, or nil. */
5ec75a55
RS
3564
3565Lisp_Object
b7c49376
RS
3566menu_bar_items (old)
3567 Lisp_Object old;
5ec75a55
RS
3568{
3569 /* The number of keymaps we're scanning right now, and the number of
3570 keymaps we have allocated space for. */
3571 int nmaps;
3572
3573 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
3574 in the current keymaps, or nil where it is not a prefix. */
3575 Lisp_Object *maps;
3576
9f9c0e27 3577 Lisp_Object def, tem, tail;
5ec75a55
RS
3578
3579 Lisp_Object result;
3580
3581 int mapno;
47d319aa 3582 Lisp_Object oquit;
5ec75a55 3583
b7c49376
RS
3584 int i;
3585
3586 struct gcpro gcpro1;
3587
db60d856
JB
3588 /* In order to build the menus, we need to call the keymap
3589 accessors. They all call QUIT. But this function is called
3590 during redisplay, during which a quit is fatal. So inhibit
47d319aa
RS
3591 quitting while building the menus.
3592 We do this instead of specbind because (1) errors will clear it anyway
3593 and (2) this avoids risk of specpdl overflow. */
3594 oquit = Vinhibit_quit;
3595 Vinhibit_quit = Qt;
db60d856 3596
b7c49376
RS
3597 if (!NILP (old))
3598 menu_bar_items_vector = old;
3599 else
3600 menu_bar_items_vector = Fmake_vector (make_number (24), Qnil);
3601 menu_bar_items_index = 0;
3602
3603 GCPRO1 (menu_bar_items_vector);
3604
5ec75a55
RS
3605 /* Build our list of keymaps.
3606 If we recognize a function key and replace its escape sequence in
3607 keybuf with its symbol, or if the sequence starts with a mouse
3608 click and we need to switch buffers, we jump back here to rebuild
3609 the initial keymaps from the current buffer. */
3610 {
3611 Lisp_Object *tmaps;
3612
9dd3131c
RS
3613 if (!NILP (Voverriding_local_map))
3614 {
3615 nmaps = 2;
3616 maps = (Lisp_Object *) alloca (nmaps * sizeof (maps[0]));
3617 maps[0] = Voverriding_local_map;
3618 }
3619 else
3620 {
3621 nmaps = current_minor_maps (0, &tmaps) + 2;
3622 maps = (Lisp_Object *) alloca (nmaps * sizeof (maps[0]));
3623 bcopy (tmaps, maps, (nmaps - 2) * sizeof (maps[0]));
5ec75a55 3624#ifdef USE_TEXT_PROPERTIES
9dd3131c 3625 maps[nmaps-2] = get_local_map (PT, current_buffer);
5ec75a55 3626#else
9dd3131c 3627 maps[nmaps-2] = current_buffer->keymap;
5ec75a55 3628#endif
9dd3131c 3629 }
7e6992e0 3630 maps[nmaps-1] = current_global_map;
5ec75a55
RS
3631 }
3632
3633 /* Look up in each map the dummy prefix key `menu-bar'. */
3634
3635 result = Qnil;
3636
e58aa385 3637 for (mapno = nmaps - 1; mapno >= 0; mapno--)
5ec75a55
RS
3638 {
3639 if (! NILP (maps[mapno]))
e74fbc70 3640 def = get_keyelt (access_keymap (maps[mapno], Qmenu_bar, 1, 0));
5ec75a55
RS
3641 else
3642 def = Qnil;
3643
3644 tem = Fkeymapp (def);
3645 if (!NILP (tem))
b7c49376 3646 menu_bar_one_keymap (def);
5ec75a55
RS
3647 }
3648
b7c49376
RS
3649 /* Move to the end those items that should be at the end. */
3650
9f9c0e27
RS
3651 for (tail = Vmenu_bar_final_items; CONSP (tail); tail = XCONS (tail)->cdr)
3652 {
b7c49376
RS
3653 int i;
3654 int end = menu_bar_items_index;
3655
3656 for (i = 0; i < end; i += 3)
3657 if (EQ (XCONS (tail)->car, XVECTOR (menu_bar_items_vector)->contents[i]))
3658 {
0301268e
RS
3659 Lisp_Object tem0, tem1, tem2;
3660 /* Move the item at index I to the end,
3661 shifting all the others forward. */
3662 tem0 = XVECTOR (menu_bar_items_vector)->contents[i + 0];
3663 tem1 = XVECTOR (menu_bar_items_vector)->contents[i + 1];
3664 tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
3665 if (end > i + 3)
3666 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 3],
3667 &XVECTOR (menu_bar_items_vector)->contents[i],
3668 (end - i - 3) * sizeof (Lisp_Object));
3669 XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem0;
3670 XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem1;
3671 XVECTOR (menu_bar_items_vector)->contents[end - 1] = tem2;
3672 break;
b7c49376
RS
3673 }
3674 }
9f9c0e27 3675
b7c49376
RS
3676 /* Add nil, nil, nil at the end. */
3677 i = menu_bar_items_index;
3678 if (i + 3 > XVECTOR (menu_bar_items_vector)->size)
3679 {
3680 Lisp_Object tem;
3681 int newsize = 2 * i;
3682 tem = Fmake_vector (make_number (2 * i), Qnil);
3683 bcopy (XVECTOR (menu_bar_items_vector)->contents,
3684 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
3685 menu_bar_items_vector = tem;
9f9c0e27 3686 }
b7c49376
RS
3687 /* Add this item. */
3688 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
3689 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
3690 XVECTOR (menu_bar_items_vector)->contents[i++] = Qnil;
3691 menu_bar_items_index = i;
a73c5e29 3692
47d319aa 3693 Vinhibit_quit = oquit;
b7c49376
RS
3694 UNGCPRO;
3695 return menu_bar_items_vector;
5ec75a55
RS
3696}
3697\f
3698/* Scan one map KEYMAP, accumulating any menu items it defines
f5e09c8b 3699 in menu_bar_items_vector. */
5ec75a55 3700
b7c49376
RS
3701static void
3702menu_bar_one_keymap (keymap)
3703 Lisp_Object keymap;
5ec75a55
RS
3704{
3705 Lisp_Object tail, item, key, binding, item_string, table;
3706
3707 /* Loop over all keymap entries that have menu strings. */
3708 for (tail = keymap; XTYPE (tail) == Lisp_Cons; tail = XCONS (tail)->cdr)
3709 {
3710 item = XCONS (tail)->car;
3711 if (XTYPE (item) == Lisp_Cons)
3712 {
3713 key = XCONS (item)->car;
3714 binding = XCONS (item)->cdr;
3715 if (XTYPE (binding) == Lisp_Cons)
3716 {
3717 item_string = XCONS (binding)->car;
3718 if (XTYPE (item_string) == Lisp_String)
b7c49376 3719 menu_bar_item (key, item_string, Fcdr (binding));
5ec75a55 3720 }
e58aa385 3721 else if (EQ (binding, Qundefined))
b7c49376 3722 menu_bar_item (key, item_string, binding);
5ec75a55
RS
3723 }
3724 else if (XTYPE (item) == Lisp_Vector)
3725 {
3726 /* Loop over the char values represented in the vector. */
3727 int len = XVECTOR (item)->size;
3728 int c;
3729 for (c = 0; c < len; c++)
3730 {
3731 Lisp_Object character;
3732 XFASTINT (character) = c;
3733 binding = XVECTOR (item)->contents[c];
3734 if (XTYPE (binding) == Lisp_Cons)
3735 {
3736 item_string = XCONS (binding)->car;
3737 if (XTYPE (item_string) == Lisp_String)
b7c49376 3738 menu_bar_item (key, item_string, Fcdr (binding));
5ec75a55 3739 }
e58aa385 3740 else if (EQ (binding, Qundefined))
b7c49376 3741 menu_bar_item (key, item_string, binding);
5ec75a55
RS
3742 }
3743 }
3744 }
5ec75a55
RS
3745}
3746
047a8ea7
RS
3747/* This is used as the handler when calling internal_condition_case_1. */
3748
3749static Lisp_Object
3750menu_bar_item_1 (arg)
3751 Lisp_Object arg;
3752{
3753 return Qnil;
3754}
3755
f5e09c8b
RS
3756/* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
3757 If there's already an item for KEY, add this DEF to it. */
3758
b7c49376
RS
3759static void
3760menu_bar_item (key, item_string, def)
3761 Lisp_Object key, item_string, def;
5ec75a55 3762{
e58aa385 3763 Lisp_Object tem;
5ec75a55 3764 Lisp_Object enabled;
b7c49376 3765 int i;
5ec75a55 3766
e58aa385
RS
3767 if (EQ (def, Qundefined))
3768 {
f5e09c8b 3769 /* If a map has an explicit `undefined' as definition,
e58aa385 3770 discard any previously made menu bar item. */
b7c49376
RS
3771
3772 for (i = 0; i < menu_bar_items_index; i += 3)
3773 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
3774 {
3775 if (menu_bar_items_index > i + 3)
3776 bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 3],
3777 &XVECTOR (menu_bar_items_vector)->contents[i],
3778 (menu_bar_items_index - i - 3) * sizeof (Lisp_Object));
3779 menu_bar_items_index -= 3;
3780 return;
3781 }
e58aa385
RS
3782 }
3783
5ec75a55
RS
3784 /* See if this entry is enabled. */
3785 enabled = Qt;
3786
3787 if (XTYPE (def) == Lisp_Symbol)
3788 {
3789 /* No property, or nil, means enable.
3790 Otherwise, enable if value is not nil. */
3791 tem = Fget (def, Qmenu_enable);
3792 if (!NILP (tem))
047a8ea7
RS
3793 /* (condition-case nil (eval tem)
3794 (error nil)) */
3795 enabled = internal_condition_case_1 (Feval, tem, Qerror,
3796 menu_bar_item_1);
5ec75a55
RS
3797 }
3798
b7c49376
RS
3799 /* Ignore this item if it's not enabled. */
3800 if (NILP (enabled))
3801 return;
5ec75a55 3802
f5e09c8b 3803 /* Find any existing item for this KEY. */
b7c49376
RS
3804 for (i = 0; i < menu_bar_items_index; i += 3)
3805 if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
3806 break;
3807
f5e09c8b 3808 /* If we did not find this KEY, add it at the end. */
b7c49376
RS
3809 if (i == menu_bar_items_index)
3810 {
3811 /* If vector is too small, get a bigger one. */
3812 if (i + 3 > XVECTOR (menu_bar_items_vector)->size)
3813 {
3814 Lisp_Object tem;
3815 int newsize = 2 * i;
3816 tem = Fmake_vector (make_number (2 * i), Qnil);
3817 bcopy (XVECTOR (menu_bar_items_vector)->contents,
3818 XVECTOR (tem)->contents, i * sizeof (Lisp_Object));
3819 menu_bar_items_vector = tem;
3820 }
3821 /* Add this item. */
3822 XVECTOR (menu_bar_items_vector)->contents[i++] = key;
3823 XVECTOR (menu_bar_items_vector)->contents[i++] = item_string;
f5e09c8b 3824 XVECTOR (menu_bar_items_vector)->contents[i++] = Fcons (def, Qnil);
b7c49376
RS
3825 menu_bar_items_index = i;
3826 }
f5e09c8b
RS
3827 /* We did find an item for this KEY. Add DEF to its list of maps. */
3828 else
3829 {
3830 Lisp_Object old;
3831 old = XVECTOR (menu_bar_items_vector)->contents[i + 2];
3832 XVECTOR (menu_bar_items_vector)->contents[i + 2] = Fcons (def, old);
3833 }
5ec75a55
RS
3834}
3835\f
dcc408a0
RS
3836/* Read a character using menus based on maps in the array MAPS.
3837 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
3838 Return t if we displayed a menu but the user rejected it.
7d6de002
RS
3839
3840 PREV_EVENT is the previous input event, or nil if we are reading
3841 the first event of a key sequence.
3842
6569cc8d
JB
3843 If USED_MOUSE_MENU is non-zero, then we set *USED_MOUSE_MENU to 1
3844 if we used a mouse menu to read the input, or zero otherwise. If
3845 USED_MOUSE_MENU is zero, *USED_MOUSE_MENU is left alone.
284f4730
JB
3846
3847 The prompting is done based on the prompt-string of the map
8150596a
RS
3848 and the strings associated with various map elements.
3849
3850 This can be done with X menus or with menus put in the minibuf.
3851 These are done in different ways, depending on how the input will be read.
3852 Menus using X are done after auto-saving in read-char, getting the input
3853 event from Fx_popup_menu; menus using the minibuf use read_char recursively
3854 and do auto-saving in the inner call of read_char. */
284f4730 3855
7617111f 3856static Lisp_Object
8150596a 3857read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu)
7d6de002
RS
3858 int nmaps;
3859 Lisp_Object *maps;
3860 Lisp_Object prev_event;
3861 int *used_mouse_menu;
284f4730 3862{
7d6de002
RS
3863 int mapno;
3864 register Lisp_Object name;
7d6de002
RS
3865 Lisp_Object rest, vector;
3866
6569cc8d
JB
3867 if (used_mouse_menu)
3868 *used_mouse_menu = 0;
284f4730
JB
3869
3870 /* Use local over global Menu maps */
3871
7d6de002
RS
3872 if (! menu_prompting)
3873 return Qnil;
3874
3875 /* Get the menu name from the first map that has one (a prompt string). */
3876 for (mapno = 0; mapno < nmaps; mapno++)
3877 {
3878 name = map_prompt (maps[mapno]);
3879 if (!NILP (name))
3880 break;
3881 }
284f4730 3882
7d6de002 3883 /* If we don't have any menus, just read a character normally. */
dbc4e1c1 3884 if (mapno >= nmaps)
7d6de002
RS
3885 return Qnil;
3886
dbc4e1c1
JB
3887#ifdef HAVE_X_WINDOWS
3888#ifdef HAVE_X_MENU
7d6de002
RS
3889 /* If we got to this point via a mouse click,
3890 use a real menu for mouse selection. */
dbc4e1c1 3891 if (EVENT_HAS_PARAMETERS (prev_event))
7d6de002
RS
3892 {
3893 /* Display the menu and get the selection. */
3894 Lisp_Object *realmaps
3895 = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
3896 Lisp_Object value;
3897 int nmaps1 = 0;
3898
3899 /* Use the maps that are not nil. */
3900 for (mapno = 0; mapno < nmaps; mapno++)
3901 if (!NILP (maps[mapno]))
3902 realmaps[nmaps1++] = maps[mapno];
3903
3904 value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
663258f2
JB
3905 if (CONSP (value))
3906 {
3907 /* If we got more than one event, put all but the first
3908 onto this list to be read later.
3909 Return just the first event now. */
24597608
RS
3910 Vunread_command_events
3911 = nconc2 (XCONS (value)->cdr, Vunread_command_events);
663258f2
JB
3912 value = XCONS (value)->car;
3913 }
1c90c381 3914 else if (NILP (value))
dcc408a0 3915 value = Qt;
6569cc8d
JB
3916 if (used_mouse_menu)
3917 *used_mouse_menu = 1;
7d6de002
RS
3918 return value;
3919 }
dbc4e1c1
JB
3920#endif /* HAVE_X_MENU */
3921#endif /* HAVE_X_WINDOWS */
8150596a
RS
3922 return Qnil ;
3923}
3924
3925static Lisp_Object
24597608 3926read_char_minibuf_menu_prompt (commandflag, nmaps, maps)
8150596a
RS
3927 int commandflag ;
3928 int nmaps;
3929 Lisp_Object *maps;
3930{
3931 int mapno;
3932 register Lisp_Object name;
3933 int nlength;
3934 int width = FRAME_WIDTH (selected_frame) - 4;
3935 char *menu = (char *) alloca (width + 4);
3936 int idx = -1;
3937 int nobindings ;
3938 Lisp_Object rest, vector;
3939
3940 if (! menu_prompting)
3941 return Qnil;
3942
3943 /* Get the menu name from the first map that has one (a prompt string). */
3944 for (mapno = 0; mapno < nmaps; mapno++)
3945 {
3946 name = map_prompt (maps[mapno]);
3947 if (!NILP (name))
3948 break;
3949 }
3950
3951 /* If we don't have any menus, just read a character normally. */
3952 if (mapno >= nmaps)
3953 return Qnil;
284f4730
JB
3954
3955 /* Prompt string always starts with map's prompt, and a space. */
3956 strcpy (menu, XSTRING (name)->data);
3957 nlength = XSTRING (name)->size;
7d6de002 3958 menu[nlength++] = ':';
284f4730
JB
3959 menu[nlength++] = ' ';
3960 menu[nlength] = 0;
3961
7d6de002
RS
3962 /* Start prompting at start of first map. */
3963 mapno = 0;
3964 rest = maps[mapno];
284f4730
JB
3965
3966 /* Present the documented bindings, a line at a time. */
3967 while (1)
3968 {
3969 int notfirst = 0;
3970 int i = nlength;
3971 Lisp_Object obj;
3972 int ch;
8150596a 3973 int orig_defn_macro ;
284f4730 3974
284f4730 3975 /* Loop over elements of map. */
7d6de002 3976 while (i < width)
284f4730 3977 {
7d6de002 3978 Lisp_Object s, elt;
284f4730 3979
7d6de002
RS
3980 /* If reached end of map, start at beginning of next map. */
3981 if (NILP (rest))
3982 {
3983 mapno++;
3984 /* At end of last map, wrap around to first map if just starting,
3985 or end this line if already have something on it. */
3986 if (mapno == nmaps)
284f4730 3987 {
8150596a 3988 mapno = 0;
40932d1a 3989 if (notfirst || nobindings) break;
284f4730 3990 }
7d6de002 3991 rest = maps[mapno];
284f4730 3992 }
7d6de002
RS
3993
3994 /* Look at the next element of the map. */
3995 if (idx >= 0)
3996 elt = XVECTOR (vector)->contents[idx];
284f4730 3997 else
7d6de002
RS
3998 elt = Fcar_safe (rest);
3999
4000 if (idx < 0 && XTYPE (elt) == Lisp_Vector)
284f4730 4001 {
7d6de002
RS
4002 /* If we found a dense table in the keymap,
4003 advanced past it, but start scanning its contents. */
4004 rest = Fcdr_safe (rest);
4005 vector = elt;
4006 idx = 0;
284f4730 4007 }
7d6de002
RS
4008 else
4009 {
4010 /* An ordinary element. */
8150596a
RS
4011 if ( idx < 0 )
4012 s = Fcar_safe (Fcdr_safe (elt)); /* alist */
4013 else
4014 s = Fcar_safe(elt); /* vector */
7d6de002
RS
4015 if (XTYPE (s) != Lisp_String)
4016 /* Ignore the element if it has no prompt string. */
4017 ;
4018 /* If we have room for the prompt string, add it to this line.
4019 If this is the first on the line, always add it. */
8150596a 4020 else if (XSTRING (s)->size + i + 2 < width
7d6de002
RS
4021 || !notfirst)
4022 {
4023 int thiswidth;
284f4730 4024
7d6de002
RS
4025 /* Punctuate between strings. */
4026 if (notfirst)
4027 {
4028 strcpy (menu + i, ", ");
4029 i += 2;
4030 }
4031 notfirst = 1;
8150596a 4032 nobindings = 0 ;
7d6de002
RS
4033
4034 /* Add as much of string as fits. */
4035 thiswidth = XSTRING (s)->size;
4036 if (thiswidth + i > width)
4037 thiswidth = width - i;
4038 bcopy (XSTRING (s)->data, menu + i, thiswidth);
4039 i += thiswidth;
8150596a 4040 menu[i] = 0;
7d6de002
RS
4041 }
4042 else
4043 {
4044 /* If this element does not fit, end the line now,
4045 and save the element for the next line. */
4046 strcpy (menu + i, "...");
4047 break;
4048 }
4049
4050 /* Move past this element. */
8150596a 4051 if (idx >= 0 && idx + 1 >= XVECTOR (vector)->size)
7d6de002
RS
4052 /* Handle reaching end of dense table. */
4053 idx = -1;
4054 if (idx >= 0)
4055 idx++;
4056 else
4057 rest = Fcdr_safe (rest);
4058 }
284f4730
JB
4059 }
4060
4061 /* Prompt with that and read response. */
4062 message1 (menu);
8150596a
RS
4063
4064 /* Make believe its not a keyboard macro in case the help char
4065 is pressed. Help characters are not recorded because menu prompting
4066 is not used on replay.
4067 */
4068 orig_defn_macro = defining_kbd_macro ;
4069 defining_kbd_macro = 0 ;
3cb81011
KH
4070 do
4071 obj = read_char (commandflag, 0, 0, Qnil, 0);
4072 while (XTYPE (obj) == Lisp_Buffer);
8150596a 4073 defining_kbd_macro = orig_defn_macro ;
284f4730
JB
4074
4075 if (XTYPE (obj) != Lisp_Int)
4076 return obj;
4077 else
4078 ch = XINT (obj);
4079
f4255cd1 4080 if (! EQ (obj, menu_prompt_more_char)
284f4730 4081 && (XTYPE (menu_prompt_more_char) != Lisp_Int
f4255cd1 4082 || ! EQ (obj, make_number (Ctl (XINT (menu_prompt_more_char))))))
8150596a
RS
4083 {
4084 if ( defining_kbd_macro )
4085 store_kbd_macro_char(obj) ;
4086 return obj;
4087 }
4088 /* Help char - go round again */
284f4730
JB
4089 }
4090}
284f4730
JB
4091\f
4092/* Reading key sequences. */
4093
4094/* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
4095 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
4096 keymap, or nil otherwise. Return the index of the first keymap in
4097 which KEY has any binding, or NMAPS if no map has a binding.
4098
4099 If KEY is a meta ASCII character, treat it like meta-prefix-char
4100 followed by the corresponding non-meta character. Keymaps in
4101 CURRENT with non-prefix bindings for meta-prefix-char become nil in
4102 NEXT.
4103
4104 When KEY is not defined in any of the keymaps, if it is an upper
4105 case letter and there are bindings for the corresponding lower-case
4106 letter, return the bindings for the lower-case letter.
e9bf89a0
RS
4107 We store 1 in *CASE_CONVERTED in this case.
4108 Otherwise, we don't change *CASE_CONVERTED.
284f4730 4109
88cb0656
JB
4110 If KEY has no bindings in any of the CURRENT maps, NEXT is left
4111 unmodified.
4112
284f4730
JB
4113 NEXT may == CURRENT. */
4114
4115static int
e9bf89a0 4116follow_key (key, nmaps, current, defs, next, case_converted)
284f4730
JB
4117 Lisp_Object key;
4118 Lisp_Object *current, *defs, *next;
4119 int nmaps;
e9bf89a0 4120 int *case_converted;
284f4730
JB
4121{
4122 int i, first_binding;
4123
4124 /* If KEY is a meta ASCII character, treat it like meta-prefix-char
4125 followed by the corresponding non-meta character. */
86e5706b 4126 if (XTYPE (key) == Lisp_Int && (XINT (key) & CHAR_META))
284f4730
JB
4127 {
4128 for (i = 0; i < nmaps; i++)
4129 if (! NILP (current[i]))
4130 {
cd21b839 4131 next[i] =
e74fbc70 4132 get_keyelt (access_keymap (current[i], meta_prefix_char, 1, 0));
284f4730
JB
4133
4134 /* Note that since we pass the resulting bindings through
4135 get_keymap_1, non-prefix bindings for meta-prefix-char
4136 disappear. */
f4255cd1 4137 next[i] = get_keymap_1 (next[i], 0, 1);
284f4730
JB
4138 }
4139 else
4140 next[i] = Qnil;
4141
4142 current = next;
86e5706b 4143 XSET (key, Lisp_Int, XFASTINT (key) & ~CHAR_META);
284f4730
JB
4144 }
4145
4146 first_binding = nmaps;
4147 for (i = nmaps - 1; i >= 0; i--)
4148 {
4149 if (! NILP (current[i]))
4150 {
e74fbc70 4151 defs[i] = get_keyelt (access_keymap (current[i], key, 1, 0));
284f4730
JB
4152 if (! NILP (defs[i]))
4153 first_binding = i;
4154 }
4155 else
4156 defs[i] = Qnil;
4157 }
4158
4159 /* When KEY is not defined in any of the keymaps, if it is an upper
4160 case letter and there are bindings for the corresponding
4161 lower-case letter, return the bindings for the lower-case letter. */
4162 if (first_binding == nmaps
4163 && XTYPE (key) == Lisp_Int
bb1ef421
RS
4164 && ((((XINT (key) & 0x3ffff)
4165 < XSTRING (current_buffer->downcase_table)->size)
4166 && UPPERCASEP (XINT (key) & 0x3ffff))
86e5706b 4167 || (XINT (key) & shift_modifier)))
284f4730 4168 {
86e5706b
RS
4169 if (XINT (key) & shift_modifier)
4170 XSETINT (key, XINT (key) & ~shift_modifier);
4171 else
398b666f
RS
4172 XSETINT (key, (DOWNCASE (XINT (key) & 0x3ffff)
4173 | (XINT (key) & ~0x3ffff)));
284f4730
JB
4174
4175 first_binding = nmaps;
4176 for (i = nmaps - 1; i >= 0; i--)
4177 {
4178 if (! NILP (current[i]))
4179 {
e74fbc70 4180 defs[i] = get_keyelt (access_keymap (current[i], key, 1, 0));
284f4730
JB
4181 if (! NILP (defs[i]))
4182 first_binding = i;
4183 }
4184 else
4185 defs[i] = Qnil;
4186 }
e9bf89a0
RS
4187 if (first_binding != nmaps)
4188 *case_converted = 1;
284f4730 4189 }
86e5706b 4190
284f4730 4191 /* Given the set of bindings we've found, produce the next set of maps. */
0a7f1fc0
JB
4192 if (first_binding < nmaps)
4193 for (i = 0; i < nmaps; i++)
f4255cd1 4194 next[i] = NILP (defs[i]) ? Qnil : get_keymap_1 (defs[i], 0, 1);
284f4730
JB
4195
4196 return first_binding;
4197}
4198
f4255cd1
JB
4199/* Read a sequence of keys that ends with a non prefix character,
4200 storing it in KEYBUF, a buffer of size BUFSIZE.
4201 Prompt with PROMPT.
284f4730 4202 Return the length of the key sequence stored.
dcc408a0 4203 Return -1 if the user rejected a command menu.
284f4730 4204
f4255cd1
JB
4205 Echo starting immediately unless `prompt' is 0.
4206
4207 Where a key sequence ends depends on the currently active keymaps.
4208 These include any minor mode keymaps active in the current buffer,
4209 the current buffer's local map, and the global map.
4210
4211 If a key sequence has no other bindings, we check Vfunction_key_map
4212 to see if some trailing subsequence might be the beginning of a
4213 function key's sequence. If so, we try to read the whole function
4214 key, and substitute its symbolic name into the key sequence.
4215
fbcd35bd
JB
4216 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
4217 `double-' events into similar click events, if that would make them
4218 bound. We try to turn `triple-' events first into `double-' events,
4219 then into clicks.
f4255cd1
JB
4220
4221 If we get a mouse click in a mode line, vertical divider, or other
4222 non-text area, we treat the click as if it were prefixed by the
4223 symbol denoting that area - `mode-line', `vertical-line', or
4224 whatever.
4225
4226 If the sequence starts with a mouse click, we read the key sequence
4227 with respect to the buffer clicked on, not the current buffer.
284f4730 4228
f4255cd1
JB
4229 If the user switches frames in the midst of a key sequence, we put
4230 off the switch-frame event until later; the next call to
4231 read_char will return it. */
48e416d4 4232
284f4730
JB
4233static int
4234read_key_sequence (keybuf, bufsize, prompt)
4235 Lisp_Object *keybuf;
4236 int bufsize;
84d91fda 4237 Lisp_Object prompt;
284f4730 4238{
f4255cd1
JB
4239 int count = specpdl_ptr - specpdl;
4240
284f4730
JB
4241 /* How many keys there are in the current key sequence. */
4242 int t;
4243
284f4730
JB
4244 /* The length of the echo buffer when we started reading, and
4245 the length of this_command_keys when we started reading. */
4246 int echo_start;
f4255cd1 4247 int keys_start;
284f4730
JB
4248
4249 /* The number of keymaps we're scanning right now, and the number of
4250 keymaps we have allocated space for. */
4251 int nmaps;
4252 int nmaps_allocated = 0;
4253
284f4730
JB
4254 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
4255 the current keymaps. */
4256 Lisp_Object *defs;
4257
f4255cd1
JB
4258 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
4259 in the current keymaps, or nil where it is not a prefix. */
4260 Lisp_Object *submaps;
4261
4262 /* The index in defs[] of the first keymap that has a binding for
4263 this key sequence. In other words, the lowest i such that
4264 defs[i] is non-nil. */
284f4730
JB
4265 int first_binding;
4266
f4255cd1 4267 /* If t < mock_input, then KEYBUF[t] should be read as the next
253598e4
JB
4268 input key.
4269
4270 We use this to recover after recognizing a function key. Once we
4271 realize that a suffix of the current key sequence is actually a
4272 function key's escape sequence, we replace the suffix with the
4273 function key's binding from Vfunction_key_map. Now keybuf
f4255cd1
JB
4274 contains a new and different key sequence, so the echo area,
4275 this_command_keys, and the submaps and defs arrays are wrong. In
4276 this situation, we set mock_input to t, set t to 0, and jump to
4277 restart_sequence; the loop will read keys from keybuf up until
4278 mock_input, thus rebuilding the state; and then it will resume
4279 reading characters from the keyboard. */
284f4730
JB
4280 int mock_input = 0;
4281
253598e4 4282 /* If the sequence is unbound in submaps[], then
f4255cd1
JB
4283 keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
4284 and fkey_map is its binding.
253598e4 4285
f4255cd1
JB
4286 These might be > t, indicating that all function key scanning
4287 should hold off until t reaches them. We do this when we've just
4288 recognized a function key, to avoid searching for the function
4289 key's again in Vfunction_key_map. */
284f4730 4290 int fkey_start = 0, fkey_end = 0;
4efda7dd 4291 Lisp_Object fkey_map;
284f4730 4292
a612e298
RS
4293 /* Likewise, for key_translation_map. */
4294 int keytran_start = 0, keytran_end = 0;
4295 Lisp_Object keytran_map;
4296
cd21b839
JB
4297 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
4298 we put it off for later. While we're reading, we keep the event here. */
4efda7dd 4299 Lisp_Object delayed_switch_frame;
cd21b839 4300
51763820
BF
4301 /* See the comment below... */
4302#if defined (GOBBLE_FIRST_EVENT)
4efda7dd 4303 Lisp_Object first_event;
51763820 4304#endif
4efda7dd 4305
3b9189f8
RS
4306 struct buffer *starting_buffer;
4307
e9bf89a0
RS
4308 /* Nonzero if we found the binding for one of the chars
4309 in this key sequence by downcasing it. */
4310 int case_converted = 0;
4311
4312 /* Nonzero if we seem to have got the beginning of a binding
4313 in function_key_map. */
4314 int function_key_possible = 0;
4315
4efda7dd
RS
4316 int junk;
4317
4318 last_nonmenu_event = Qnil;
4319
4320 delayed_switch_frame = Qnil;
4321 fkey_map = Vfunction_key_map;
a612e298 4322 keytran_map = Vkey_translation_map;
f4255cd1 4323
a612e298 4324 /* If there is no function-key-map, turn off function key scanning. */
f4255cd1
JB
4325 if (NILP (Fkeymapp (Vfunction_key_map)))
4326 fkey_start = fkey_end = bufsize + 1;
4327
a612e298
RS
4328 /* If there is no key-translation-map, turn off scanning. */
4329 if (NILP (Fkeymapp (Vkey_translation_map)))
4330 keytran_start = keytran_end = bufsize + 1;
4331
284f4730
JB
4332 if (INTERACTIVE)
4333 {
84d91fda
RS
4334 if (!NILP (prompt))
4335 echo_prompt (XSTRING (prompt)->data);
284f4730
JB
4336 else if (cursor_in_echo_area)
4337 /* This doesn't put in a dash if the echo buffer is empty, so
4338 you don't always see a dash hanging out in the minibuffer. */
4339 echo_dash ();
284f4730
JB
4340 }
4341
f4255cd1
JB
4342 /* Record the initial state of the echo area and this_command_keys;
4343 we will need to restore them if we replay a key sequence. */
0a7f1fc0 4344 if (INTERACTIVE)
f4255cd1
JB
4345 echo_start = echo_length ();
4346 keys_start = this_command_key_count;
0a7f1fc0 4347
51763820
BF
4348#if defined (GOBBLE_FIRST_EVENT)
4349 /* This doesn't quite work, because some of the things that read_char
4350 does cannot safely be bypassed. It seems too risky to try to make
4351 this work right. */
4352
4efda7dd
RS
4353 /* Read the first char of the sequence specially, before setting
4354 up any keymaps, in case a filter runs and switches buffers on us. */
84d91fda 4355 first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
4efda7dd 4356 &junk);
51763820 4357#endif /* GOBBLE_FIRST_EVENT */
4efda7dd 4358
7b4aedb9
JB
4359 /* We jump here when the key sequence has been thoroughly changed, and
4360 we need to rescan it starting from the beginning. When we jump here,
4361 keybuf[0..mock_input] holds the sequence we should reread. */
07d2b8de 4362 replay_sequence:
7b4aedb9 4363
3b9189f8 4364 starting_buffer = current_buffer;
e9bf89a0
RS
4365 case_converted = 0;
4366 function_key_possible = 0;
3b9189f8 4367
f4255cd1 4368 /* Build our list of keymaps.
07d2b8de
JB
4369 If we recognize a function key and replace its escape sequence in
4370 keybuf with its symbol, or if the sequence starts with a mouse
4371 click and we need to switch buffers, we jump back here to rebuild
4372 the initial keymaps from the current buffer. */
284f4730
JB
4373 {
4374 Lisp_Object *maps;
4375
9dd3131c 4376 if (!NILP (Voverriding_local_map))
284f4730 4377 {
9dd3131c
RS
4378 nmaps = 2;
4379 if (nmaps > nmaps_allocated)
4380 {
4381 submaps = (Lisp_Object *) alloca (nmaps * sizeof (submaps[0]));
4382 defs = (Lisp_Object *) alloca (nmaps * sizeof (defs[0]));
4383 nmaps_allocated = nmaps;
4384 }
4385 submaps[0] = Voverriding_local_map;
284f4730 4386 }
9dd3131c
RS
4387 else
4388 {
4389 nmaps = current_minor_maps (0, &maps) + 2;
4390 if (nmaps > nmaps_allocated)
4391 {
4392 submaps = (Lisp_Object *) alloca (nmaps * sizeof (submaps[0]));
4393 defs = (Lisp_Object *) alloca (nmaps * sizeof (defs[0]));
4394 nmaps_allocated = nmaps;
4395 }
4396 bcopy (maps, submaps, (nmaps - 2) * sizeof (submaps[0]));
497ba7a1 4397#ifdef USE_TEXT_PROPERTIES
9dd3131c 4398 submaps[nmaps-2] = get_local_map (PT, current_buffer);
497ba7a1 4399#else
9dd3131c 4400 submaps[nmaps-2] = current_buffer->keymap;
497ba7a1 4401#endif
9dd3131c 4402 }
7e6992e0 4403 submaps[nmaps-1] = current_global_map;
284f4730
JB
4404 }
4405
4406 /* Find an accurate initial value for first_binding. */
4407 for (first_binding = 0; first_binding < nmaps; first_binding++)
253598e4 4408 if (! NILP (submaps[first_binding]))
284f4730
JB
4409 break;
4410
3b9189f8 4411 /* Start from the beginning in keybuf. */
f4255cd1
JB
4412 t = 0;
4413
4414 /* These are no-ops the first time through, but if we restart, they
4415 revert the echo area and this_command_keys to their original state. */
4416 this_command_key_count = keys_start;
40932d1a 4417 if (INTERACTIVE && t < mock_input)
f4255cd1
JB
4418 echo_truncate (echo_start);
4419
cca310da
JB
4420 /* If the best binding for the current key sequence is a keymap, or
4421 we may be looking at a function key's escape sequence, keep on
4422 reading. */
253598e4 4423 while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
cca310da
JB
4424 || (first_binding >= nmaps
4425 && fkey_start < t
4426 /* mock input is never part of a function key's sequence. */
a612e298
RS
4427 && mock_input <= fkey_start)
4428 || (first_binding >= nmaps
4429 && keytran_start < t
4430 /* mock input is never part of a function key's sequence. */
e9bf89a0
RS
4431 && mock_input <= keytran_start)
4432 /* Don't return in the middle of a possible function key sequence,
4433 if the only bindings we found were via case conversion.
4434 Thus, if ESC O a has a function-key-map translation
4435 and ESC o has a binding, don't return after ESC O,
4436 so that we can translate ESC O plus the next character. */
4437 || (function_key_possible && case_converted))
284f4730
JB
4438 {
4439 Lisp_Object key;
7d6de002 4440 int used_mouse_menu = 0;
284f4730 4441
7b4aedb9
JB
4442 /* Where the last real key started. If we need to throw away a
4443 key that has expanded into more than one element of keybuf
4444 (say, a mouse click on the mode line which is being treated
4445 as [mode-line (mouse-...)], then we backtrack to this point
4446 of keybuf. */
4447 int last_real_key_start;
4448
0a7f1fc0
JB
4449 /* These variables are analogous to echo_start and keys_start;
4450 while those allow us to restart the entire key sequence,
4451 echo_local_start and keys_local_start allow us to throw away
4452 just one key. */
f4255cd1
JB
4453 int echo_local_start, keys_local_start, local_first_binding;
4454
284f4730
JB
4455 if (t >= bufsize)
4456 error ("key sequence too long");
4457
f4255cd1
JB
4458 if (INTERACTIVE)
4459 echo_local_start = echo_length ();
4460 keys_local_start = this_command_key_count;
4461 local_first_binding = first_binding;
4462
4463 replay_key:
0a7f1fc0 4464 /* These are no-ops, unless we throw away a keystroke below and
f4255cd1
JB
4465 jumped back up to replay_key; in that case, these restore the
4466 variables to their original state, allowing us to replay the
0a7f1fc0 4467 loop. */
40932d1a 4468 if (INTERACTIVE && t < mock_input)
f4255cd1 4469 echo_truncate (echo_local_start);
0a7f1fc0
JB
4470 this_command_key_count = keys_local_start;
4471 first_binding = local_first_binding;
4472
7e85b935
RS
4473 /* By default, assume each event is "real". */
4474 last_real_key_start = t;
4475
f4255cd1 4476 /* Does mock_input indicate that we are re-reading a key sequence? */
284f4730
JB
4477 if (t < mock_input)
4478 {
4479 key = keybuf[t];
4480 add_command_key (key);
4481 echo_char (key);
4482 }
253598e4
JB
4483
4484 /* If not, we should actually read a character. */
284f4730
JB
4485 else
4486 {
a6d53864
RS
4487 struct buffer *buf = current_buffer;
4488
84d91fda 4489 key = read_char (NILP (prompt), nmaps, submaps, last_nonmenu_event,
a6d53864 4490 &used_mouse_menu);
284f4730 4491
dcc408a0
RS
4492 /* read_char returns t when it shows a menu and the user rejects it.
4493 Just return -1. */
4494 if (EQ (key, Qt))
4495 return -1;
4496
f4255cd1 4497 /* read_char returns -1 at the end of a macro.
284f4730
JB
4498 Emacs 18 handles this by returning immediately with a
4499 zero, so that's what we'll do. */
86e5706b 4500 if (XTYPE (key) == Lisp_Int && XINT (key) == -1)
cd21b839 4501 {
f4255cd1
JB
4502 t = 0;
4503 goto done;
cd21b839 4504 }
284f4730 4505
3cb81011
KH
4506 /* If the current buffer has been changed from under us, the
4507 keymap may have changed, so replay the sequence. */
4508 if (XTYPE (key) == Lisp_Buffer)
4509 {
4510 mock_input = t;
4511 goto replay_sequence;
4512 }
4513
3b9189f8
RS
4514 /* If we have a quit that was typed in another frame, and
4515 quit_throw_to_read_char switched buffers,
4516 replay to get the right keymap. */
4517 if (EQ (key, quit_char) && current_buffer != starting_buffer)
4518 {
4519 keybuf[t++] = key;
4520 mock_input = t;
4521 Vquit_flag = Qnil;
4522 goto replay_sequence;
4523 }
3cb81011 4524
284f4730 4525 Vquit_flag = Qnil;
7e85b935 4526 }
284f4730 4527
7e85b935
RS
4528 /* Clicks in non-text areas get prefixed by the symbol
4529 in their CHAR-ADDRESS field. For example, a click on
4530 the mode line is prefixed by the symbol `mode-line'.
4531
4532 Furthermore, key sequences beginning with mouse clicks
4533 are read using the keymaps of the buffer clicked on, not
4534 the current buffer. So we may have to switch the buffer
4535 here.
4536
4537 When we turn one event into two events, we must make sure
4538 that neither of the two looks like the original--so that,
4539 if we replay the events, they won't be expanded again.
4540 If not for this, such reexpansion could happen either here
4541 or when user programs play with this-command-keys. */
4542 if (EVENT_HAS_PARAMETERS (key))
4543 {
9b8eb840 4544 Lisp_Object kind;
cca310da 4545
9b8eb840 4546 kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
7e85b935 4547 if (EQ (kind, Qmouse_click))
0a7f1fc0 4548 {
9b8eb840 4549 Lisp_Object window, posn;
f4255cd1 4550
9b8eb840
KH
4551 window = POSN_WINDOW (EVENT_START (key));
4552 posn = POSN_BUFFER_POSN (EVENT_START (key));
7e85b935 4553 if (XTYPE (posn) == Lisp_Cons)
0a7f1fc0 4554 {
7e85b935
RS
4555 /* We're looking at the second event of a
4556 sequence which we expanded before. Set
4557 last_real_key_start appropriately. */
4558 if (t > 0)
4559 last_real_key_start = t - 1;
cd21b839 4560 }
7e85b935
RS
4561
4562 /* Key sequences beginning with mouse clicks are
4563 read using the keymaps in the buffer clicked on,
4564 not the current buffer. If we're at the
4565 beginning of a key sequence, switch buffers. */
4566 if (last_real_key_start == 0
4567 && XTYPE (window) == Lisp_Window
4568 && XTYPE (XWINDOW (window)->buffer) == Lisp_Buffer
4569 && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
cd21b839 4570 {
7e85b935
RS
4571 keybuf[t] = key;
4572 mock_input = t + 1;
4573
4574 /* Arrange to go back to the original buffer once we're
4575 done reading the key sequence. Note that we can't
4576 use save_excursion_{save,restore} here, because they
4577 save point as well as the current buffer; we don't
4578 want to save point, because redisplay may change it,
4579 to accommodate a Fset_window_start or something. We
4580 don't want to do this at the top of the function,
4581 because we may get input from a subprocess which
4582 wants to change the selected window and stuff (say,
4583 emacsclient). */
4584 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
4585
4586 set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
4587 goto replay_sequence;
0a7f1fc0 4588 }
7e85b935 4589 else if (XTYPE (posn) == Lisp_Symbol)
5ec75a55 4590 {
7e85b935
RS
4591 /* Expand mode-line and scroll-bar events into two events:
4592 use posn as a fake prefix key. */
5ec75a55 4593
7e85b935
RS
4594 if (t + 1 >= bufsize)
4595 error ("key sequence too long");
4596 keybuf[t] = posn;
4597 keybuf[t+1] = key;
4598 mock_input = t + 2;
4599
4600 /* Zap the position in key, so we know that we've
4601 expanded it, and don't try to do so again. */
4602 POSN_BUFFER_POSN (EVENT_START (key))
4603 = Fcons (posn, Qnil);
4604 goto replay_key;
5ec75a55 4605 }
0a7f1fc0 4606 }
7e85b935 4607 else if (EQ (kind, Qswitch_frame))
a6d53864 4608 {
7e85b935
RS
4609 /* If we're at the beginning of a key sequence, go
4610 ahead and return this event. If we're in the
4611 midst of a key sequence, delay it until the end. */
4612 if (t > 0)
4613 {
4614 delayed_switch_frame = key;
4615 goto replay_key;
4616 }
4617 }
4618 else
4619 {
9b8eb840 4620 Lisp_Object posn;
7e85b935 4621
9b8eb840 4622 posn = POSN_BUFFER_POSN (EVENT_START (key));
7e85b935
RS
4623 /* Handle menu-bar events:
4624 insert the dummy prefix event `menu-bar'. */
4625 if (EQ (posn, Qmenu_bar))
4626 {
4627 if (t + 1 >= bufsize)
4628 error ("key sequence too long");
4629 /* Run the Lucid hook. */
88ce066e
RS
4630 if (!NILP (Vrun_hooks))
4631 call1 (Vrun_hooks, Qactivate_menubar_hook);
7e85b935
RS
4632 /* If it has changed current-menubar from previous value,
4633 really recompute the menubar from the value. */
4634 if (! NILP (Vlucid_menu_bar_dirty_flag))
4635 call0 (Qrecompute_lucid_menubar);
4636 keybuf[t] = posn;
4637 keybuf[t+1] = key;
4638
4639 /* Zap the position in key, so we know that we've
4640 expanded it, and don't try to do so again. */
4641 POSN_BUFFER_POSN (EVENT_START (key))
4642 = Fcons (posn, Qnil);
4643
4644 mock_input = t + 2;
4645 goto replay_sequence;
4646 }
4647 else if (XTYPE (posn) == Lisp_Cons)
4648 {
4649 /* We're looking at the second event of a
4650 sequence which we expanded before. Set
4651 last_real_key_start appropriately. */
4652 if (last_real_key_start == t && t > 0)
4653 last_real_key_start = t - 1;
4654 }
a6d53864 4655 }
284f4730 4656 }
f4255cd1
JB
4657
4658 /* We have finally decided that KEY is something we might want
4659 to look up. */
284f4730
JB
4660 first_binding = (follow_key (key,
4661 nmaps - first_binding,
253598e4 4662 submaps + first_binding,
284f4730 4663 defs + first_binding,
e9bf89a0
RS
4664 submaps + first_binding,
4665 &case_converted)
284f4730 4666 + first_binding);
0a7f1fc0 4667
f4255cd1 4668 /* If KEY wasn't bound, we'll try some fallbacks. */
0a7f1fc0
JB
4669 if (first_binding >= nmaps)
4670 {
9b8eb840 4671 Lisp_Object head;
0a7f1fc0 4672
9b8eb840 4673 head = EVENT_HEAD (key);
7e85b935
RS
4674 if (EQ (head, Vhelp_char))
4675 {
4676 read_key_sequence_cmd = Vprefix_help_command;
4677 keybuf[t++] = key;
4678 last_nonmenu_event = key;
4679 goto done;
4680 }
4681
0a7f1fc0
JB
4682 if (XTYPE (head) == Lisp_Symbol)
4683 {
9b8eb840
KH
4684 Lisp_Object breakdown;
4685 int modifiers;
0a7f1fc0 4686
9b8eb840
KH
4687 breakdown = parse_modifiers (head);
4688 modifiers = XINT (XCONS (XCONS (breakdown)->cdr)->car);
559f9d04
RS
4689 /* Attempt to reduce an unbound mouse event to a simpler
4690 event that is bound:
4691 Drags reduce to clicks.
4692 Double-clicks reduce to clicks.
4693 Triple-clicks reduce to double-clicks, then to clicks.
4694 Down-clicks are eliminated.
4695 Double-downs reduce to downs, then are eliminated.
4696 Triple-downs reduce to double-downs, then to downs,
4697 then are eliminated. */
4698 if (modifiers & (down_modifier | drag_modifier
4699 | double_modifier | triple_modifier))
0a7f1fc0 4700 {
559f9d04
RS
4701 while (modifiers & (down_modifier | drag_modifier
4702 | double_modifier | triple_modifier))
fbcd35bd
JB
4703 {
4704 Lisp_Object new_head, new_click;
4705 if (modifiers & triple_modifier)
4706 modifiers ^= (double_modifier | triple_modifier);
559f9d04 4707 else if (modifiers & (drag_modifier | double_modifier))
fbcd35bd 4708 modifiers &= ~(drag_modifier | double_modifier);
559f9d04
RS
4709 else
4710 {
4711 /* Dispose of this `down' event by simply jumping
4712 back to replay_key, to get another event.
4713
4714 Note that if this event came from mock input,
4715 then just jumping back to replay_key will just
4716 hand it to us again. So we have to wipe out any
4717 mock input.
4718
4719 We could delete keybuf[t] and shift everything
4720 after that to the left by one spot, but we'd also
4721 have to fix up any variable that points into
4722 keybuf, and shifting isn't really necessary
4723 anyway.
4724
4725 Adding prefixes for non-textual mouse clicks
4726 creates two characters of mock input, and both
4727 must be thrown away. If we're only looking at
4728 the prefix now, we can just jump back to
4729 replay_key. On the other hand, if we've already
4730 processed the prefix, and now the actual click
4731 itself is giving us trouble, then we've lost the
4732 state of the keymaps we want to backtrack to, and
4733 we need to replay the whole sequence to rebuild
4734 it.
4735
4736 Beyond that, only function key expansion could
4737 create more than two keys, but that should never
4738 generate mouse events, so it's okay to zero
4739 mock_input in that case too.
4740
4741 Isn't this just the most wonderful code ever? */
4742 if (t == last_real_key_start)
4743 {
4744 mock_input = 0;
4745 goto replay_key;
4746 }
4747 else
4748 {
4749 mock_input = last_real_key_start;
4750 goto replay_sequence;
4751 }
4752 }
4753
27203ead
RS
4754 new_head
4755 = apply_modifiers (modifiers, XCONS (breakdown)->car);
4756 new_click
4757 = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
fbcd35bd
JB
4758
4759 /* Look for a binding for this new key. follow_key
4760 promises that it didn't munge submaps the
4761 last time we called it, since key was unbound. */
27203ead
RS
4762 first_binding
4763 = (follow_key (new_click,
4764 nmaps - local_first_binding,
4765 submaps + local_first_binding,
4766 defs + local_first_binding,
e9bf89a0
RS
4767 submaps + local_first_binding,
4768 &case_converted)
27203ead 4769 + local_first_binding);
fbcd35bd
JB
4770
4771 /* If that click is bound, go for it. */
4772 if (first_binding < nmaps)
4773 {
4774 key = new_click;
4775 break;
4776 }
4777 /* Otherwise, we'll leave key set to the drag event. */
4778 }
0a7f1fc0
JB
4779 }
4780 }
4781 }
4782
284f4730 4783 keybuf[t++] = key;
7d6de002
RS
4784 /* Normally, last_nonmenu_event gets the previous key we read.
4785 But when a mouse popup menu is being used,
4786 we don't update last_nonmenu_event; it continues to hold the mouse
4787 event that preceded the first level of menu. */
4788 if (!used_mouse_menu)
4789 last_nonmenu_event = key;
284f4730
JB
4790
4791 /* If the sequence is unbound, see if we can hang a function key
253598e4
JB
4792 off the end of it. We only want to scan real keyboard input
4793 for function key sequences, so if mock_input says that we're
f4255cd1 4794 re-reading old events, don't examine it. */
e9bf89a0 4795 if ((first_binding >= nmaps || case_converted)
253598e4 4796 && t >= mock_input)
284f4730
JB
4797 {
4798 Lisp_Object fkey_next;
4799
e9bf89a0
RS
4800 /* Continue scan from fkey_end until we find a bound suffix.
4801 If we fail, increment fkey_start
4802 and start fkey_end from there. */
284f4730
JB
4803 while (fkey_end < t)
4804 {
f4255cd1
JB
4805 Lisp_Object key;
4806
4807 key = keybuf[fkey_end++];
067ffa38
JB
4808 /* Look up meta-characters by prefixing them
4809 with meta_prefix_char. I hate this. */
d3cc13fa 4810 if (XTYPE (key) == Lisp_Int && XINT (key) & meta_modifier)
f4255cd1 4811 {
e74fbc70
RS
4812 fkey_next
4813 = get_keymap_1
f4255cd1 4814 (get_keyelt
e74fbc70 4815 (access_keymap (fkey_map, meta_prefix_char, 1, 0)),
f4255cd1 4816 0, 1);
d3cc13fa 4817 XFASTINT (key) = XFASTINT (key) & ~meta_modifier;
f4255cd1 4818 }
067ffa38
JB
4819 else
4820 fkey_next = fkey_map;
4821
e74fbc70
RS
4822 fkey_next
4823 = get_keyelt (access_keymap (fkey_next, key, 1, 0));
067ffa38 4824
1abe6abe
RS
4825 /* If the function key map gives a function, not an
4826 array, then call the function with no args and use
4827 its value instead. */
4828 if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
4829 && fkey_end == t)
4830 {
4831 struct gcpro gcpro1, gcpro2, gcpro3;
4832 Lisp_Object tem;
4833 tem = fkey_next;
4834
4835 GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
84d91fda 4836 fkey_next = call1 (fkey_next, prompt);
1abe6abe
RS
4837 UNGCPRO;
4838 /* If the function returned something invalid,
4839 barf--don't ignore it.
4840 (To ignore it safely, we would need to gcpro a bunch of
4841 other variables.) */
4842 if (! (VECTORP (fkey_next) || STRINGP (fkey_next)))
4843 error ("Function in function-key-map returns invalid key sequence");
4844 }
4845
e9bf89a0
RS
4846 function_key_possible = ! NILP (fkey_next);
4847
85bc5181 4848 /* If keybuf[fkey_start..fkey_end] is bound in the
a764a753 4849 function key map and it's a suffix of the current
85bc5181 4850 sequence (i.e. fkey_end == t), replace it with
a764a753 4851 the binding and restart with fkey_start at the end. */
f5ea6163 4852 if ((VECTORP (fkey_next) || STRINGP (fkey_next))
284f4730
JB
4853 && fkey_end == t)
4854 {
2e864a76 4855 int len = XFASTINT (Flength (fkey_next));
f5ea6163
JB
4856
4857 t = fkey_start + len;
284f4730
JB
4858 if (t >= bufsize)
4859 error ("key sequence too long");
4860
f5ea6163
JB
4861 if (VECTORP (fkey_next))
4862 bcopy (XVECTOR (fkey_next)->contents,
4863 keybuf + fkey_start,
4864 (t - fkey_start) * sizeof (keybuf[0]));
4865 else if (STRINGP (fkey_next))
4866 {
4867 int i;
4868
4869 for (i = 0; i < len; i++)
1abe6abe
RS
4870 XFASTINT (keybuf[fkey_start + i])
4871 = XSTRING (fkey_next)->data[i];
f5ea6163 4872 }
284f4730
JB
4873
4874 mock_input = t;
4875 fkey_start = fkey_end = t;
32e6d806 4876 fkey_map = Vfunction_key_map;
284f4730 4877
f4255cd1 4878 goto replay_sequence;
284f4730
JB
4879 }
4880
f4255cd1 4881 fkey_map = get_keymap_1 (fkey_next, 0, 1);
284f4730 4882
a764a753
JB
4883 /* If we no longer have a bound suffix, try a new positions for
4884 fkey_start. */
284f4730
JB
4885 if (NILP (fkey_map))
4886 {
4887 fkey_end = ++fkey_start;
4888 fkey_map = Vfunction_key_map;
e9bf89a0 4889 function_key_possible = 0;
284f4730
JB
4890 }
4891 }
4892 }
a612e298
RS
4893
4894 /* Look for this sequence in key-translation-map. */
4895 {
4896 Lisp_Object keytran_next;
4897
4898 /* Scan from keytran_end until we find a bound suffix. */
4899 while (keytran_end < t)
4900 {
4901 Lisp_Object key;
4902
4903 key = keybuf[keytran_end++];
4904 /* Look up meta-characters by prefixing them
4905 with meta_prefix_char. I hate this. */
4906 if (XTYPE (key) == Lisp_Int && XINT (key) & meta_modifier)
4907 {
4908 keytran_next
4909 = get_keymap_1
4910 (get_keyelt
4911 (access_keymap (keytran_map, meta_prefix_char, 1, 0)),
4912 0, 1);
4913 XFASTINT (key) = XFASTINT (key) & ~meta_modifier;
4914 }
4915 else
4916 keytran_next = keytran_map;
4917
4918 keytran_next
4919 = get_keyelt (access_keymap (keytran_next, key, 1, 0));
4920
1abe6abe
RS
4921 /* If the key translation map gives a function, not an
4922 array, then call the function with no args and use
4923 its value instead. */
4924 if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
4925 && keytran_end == t)
4926 {
4927 struct gcpro gcpro1, gcpro2, gcpro3;
4928 Lisp_Object tem;
4929 tem = keytran_next;
4930
40932d1a 4931 GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
84d91fda 4932 keytran_next = call1 (keytran_next, prompt);
1abe6abe
RS
4933 UNGCPRO;
4934 /* If the function returned something invalid,
4935 barf--don't ignore it.
4936 (To ignore it safely, we would need to gcpro a bunch of
4937 other variables.) */
4938 if (! (VECTORP (keytran_next) || STRINGP (keytran_next)))
40932d1a 4939 error ("Function in key-translation-map returns invalid key sequence");
1abe6abe
RS
4940 }
4941
a612e298 4942 /* If keybuf[keytran_start..keytran_end] is bound in the
1abe6abe 4943 key translation map and it's a suffix of the current
a612e298
RS
4944 sequence (i.e. keytran_end == t), replace it with
4945 the binding and restart with keytran_start at the end. */
4946 if ((VECTORP (keytran_next) || STRINGP (keytran_next))
4947 && keytran_end == t)
4948 {
2e864a76 4949 int len = XFASTINT (Flength (keytran_next));
a612e298
RS
4950
4951 t = keytran_start + len;
4952 if (t >= bufsize)
4953 error ("key sequence too long");
4954
4955 if (VECTORP (keytran_next))
4956 bcopy (XVECTOR (keytran_next)->contents,
4957 keybuf + keytran_start,
4958 (t - keytran_start) * sizeof (keybuf[0]));
4959 else if (STRINGP (keytran_next))
4960 {
4961 int i;
4962
4963 for (i = 0; i < len; i++)
4964 XFASTINT (keybuf[keytran_start + i])
4965 = XSTRING (keytran_next)->data[i];
4966 }
4967
4968 mock_input = t;
4969 keytran_start = keytran_end = t;
4970 keytran_map = Vkey_translation_map;
4971
4972 goto replay_sequence;
4973 }
4974
4975 keytran_map = get_keymap_1 (keytran_next, 0, 1);
4976
4977 /* If we no longer have a bound suffix, try a new positions for
4978 keytran_start. */
4979 if (NILP (keytran_map))
4980 {
4981 keytran_end = ++keytran_start;
4982 keytran_map = Vkey_translation_map;
4983 }
4984 }
4985 }
284f4730
JB
4986 }
4987
4988 read_key_sequence_cmd = (first_binding < nmaps
4989 ? defs[first_binding]
4990 : Qnil);
4991
f4255cd1 4992 done:
cd21b839 4993 unread_switch_frame = delayed_switch_frame;
f4255cd1 4994 unbind_to (count, Qnil);
07f76a14
JB
4995
4996 /* Occasionally we fabricate events, perhaps by expanding something
4997 according to function-key-map, or by adding a prefix symbol to a
4998 mouse click in the scroll bar or modeline. In this cases, return
4999 the entire generated key sequence, even if we hit an unbound
5000 prefix or a definition before the end. This means that you will
5001 be able to push back the event properly, and also means that
5002 read-key-sequence will always return a logical unit.
5003
5004 Better ideas? */
cca310da
JB
5005 for (; t < mock_input; t++)
5006 {
5007 echo_char (keybuf[t]);
5008 add_command_key (keybuf[t]);
5009 }
07f76a14 5010
284f4730
JB
5011 return t;
5012}
5013
a612e298
RS
5014#if 0 /* This doc string is too long for some compilers.
5015 This commented-out definition serves for DOC. */
c0a58692 5016DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 2, 0,
284f4730
JB
5017 "Read a sequence of keystrokes and return as a string or vector.\n\
5018The sequence is sufficient to specify a non-prefix command in the\n\
5019current local and global maps.\n\
5020\n\
c0a58692
RS
5021First arg PROMPT is a prompt string. If nil, do not prompt specially.\n\
5022Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
5023as a continuation of the previous key.\n\
284f4730 5024\n\
cb5df6ae
JB
5025A C-g typed while in this function is treated like any other character,\n\
5026and `quit-flag' is not set.\n\
5027\n\
5028If the key sequence starts with a mouse click, then the sequence is read\n\
5029using the keymaps of the buffer of the window clicked in, not the buffer\n\
5030of the selected window as normal.\n\
ede41463 5031""\n\
cb5df6ae
JB
5032`read-key-sequence' drops unbound button-down events, since you normally\n\
5033only care about the click or drag events which follow them. If a drag\n\
fbcd35bd
JB
5034or multi-click event is unbound, but the corresponding click event would\n\
5035be bound, `read-key-sequence' turns the event into a click event at the\n\
cb5df6ae 5036drag's starting position. This means that you don't have to distinguish\n\
fbcd35bd 5037between click and drag, double, or triple events unless you want to.\n\
cb5df6ae
JB
5038\n\
5039`read-key-sequence' prefixes mouse events on mode lines, the vertical\n\
3c370943
JB
5040lines separating windows, and scroll bars with imaginary keys\n\
5041`mode-line', `vertical-line', and `vertical-scroll-bar'.\n\
cb5df6ae
JB
5042\n\
5043If the user switches frames in the middle of a key sequence, the\n\
5044frame-switch event is put off until after the current key sequence.\n\
5045\n\
5046`read-key-sequence' checks `function-key-map' for function key\n\
5047sequences, where they wouldn't conflict with ordinary bindings. See\n\
4bb994d1 5048`function-key-map' for more details.")
a612e298
RS
5049 (prompt, continue_echo)
5050#endif
5051
5052DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 2, 0,
5053 0)
c0a58692
RS
5054 (prompt, continue_echo)
5055 Lisp_Object prompt, continue_echo;
284f4730
JB
5056{
5057 Lisp_Object keybuf[30];
5058 register int i;
5059 struct gcpro gcpro1, gcpro2;
5060
5061 if (!NILP (prompt))
5062 CHECK_STRING (prompt, 0);
5063 QUIT;
5064
5065 bzero (keybuf, sizeof keybuf);
5066 GCPRO1 (keybuf[0]);
5067 gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
5068
daa37602 5069 if (NILP (continue_echo))
c0a58692
RS
5070 this_command_key_count = 0;
5071
84d91fda 5072 i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])), prompt);
284f4730 5073
dcc408a0
RS
5074 if (i == -1)
5075 {
5076 Vquit_flag = Qt;
5077 QUIT;
5078 }
284f4730 5079 UNGCPRO;
86e5706b 5080 return make_event_array (i, keybuf);
284f4730
JB
5081}
5082\f
5083DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 2, 0,
5084 "Execute CMD as an editor command.\n\
5085CMD must be a symbol that satisfies the `commandp' predicate.\n\
5086Optional second arg RECORD-FLAG non-nil\n\
5087means unconditionally put this command in `command-history'.\n\
5088Otherwise, that is done only if an arg is read using the minibuffer.")
5089 (cmd, record)
5090 Lisp_Object cmd, record;
5091{
5092 register Lisp_Object final;
5093 register Lisp_Object tem;
5094 Lisp_Object prefixarg;
5095 struct backtrace backtrace;
5096 extern int debug_on_next_call;
5097
5098 prefixarg = Vprefix_arg, Vprefix_arg = Qnil;
5099 Vcurrent_prefix_arg = prefixarg;
5100 debug_on_next_call = 0;
5101
5102 if (XTYPE (cmd) == Lisp_Symbol)
5103 {
5104 tem = Fget (cmd, Qdisabled);
88ce066e 5105 if (!NILP (tem) && !NILP (Vrun_hooks))
2e894dab 5106 return call1 (Vrun_hooks, Qdisabled_command_hook);
284f4730
JB
5107 }
5108
5109 while (1)
5110 {
ffd56f97 5111 final = Findirect_function (cmd);
284f4730
JB
5112
5113 if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
5114 do_autoload (final, cmd);
5115 else
5116 break;
5117 }
5118
5119 if (XTYPE (final) == Lisp_String
5120 || XTYPE (final) == Lisp_Vector)
5121 {
5122 /* If requested, place the macro in the command history. For
5123 other sorts of commands, call-interactively takes care of
5124 this. */
5125 if (!NILP (record))
5126 Vcommand_history
5127 = Fcons (Fcons (Qexecute_kbd_macro,
5128 Fcons (final, Fcons (prefixarg, Qnil))),
5129 Vcommand_history);
5130
5131 return Fexecute_kbd_macro (final, prefixarg);
5132 }
5133 if (CONSP (final) || XTYPE (final) == Lisp_Subr
5134 || XTYPE (final) == Lisp_Compiled)
5135 {
5136 backtrace.next = backtrace_list;
5137 backtrace_list = &backtrace;
5138 backtrace.function = &Qcall_interactively;
5139 backtrace.args = &cmd;
5140 backtrace.nargs = 1;
5141 backtrace.evalargs = 0;
5142
5143 tem = Fcall_interactively (cmd, record);
5144
5145 backtrace_list = backtrace.next;
5146 return tem;
5147 }
5148 return Qnil;
5149}
5150\f
284f4730
JB
5151DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
5152 1, 1, "P",
5153 "Read function name, then read its arguments and call it.")
5154 (prefixarg)
5155 Lisp_Object prefixarg;
5156{
5157 Lisp_Object function;
5158 char buf[40];
5159 Lisp_Object saved_keys;
5160 struct gcpro gcpro1;
5161
b0f2a7bf
KH
5162 saved_keys = Fvector (this_command_key_count,
5163 XVECTOR (this_command_keys)->contents);
284f4730
JB
5164 buf[0] = 0;
5165 GCPRO1 (saved_keys);
5166
5167 if (EQ (prefixarg, Qminus))
5168 strcpy (buf, "- ");
5169 else if (CONSP (prefixarg) && XINT (XCONS (prefixarg)->car) == 4)
5170 strcpy (buf, "C-u ");
5171 else if (CONSP (prefixarg) && XTYPE (XCONS (prefixarg)->car) == Lisp_Int)
5172 sprintf (buf, "%d ", XINT (XCONS (prefixarg)->car));
5173 else if (XTYPE (prefixarg) == Lisp_Int)
5174 sprintf (buf, "%d ", XINT (prefixarg));
5175
5176 /* This isn't strictly correct if execute-extended-command
5177 is bound to anything else. Perhaps it should use
5178 this_command_keys? */
5179 strcat (buf, "M-x ");
5180
5181 /* Prompt with buf, and then read a string, completing from and
5182 restricting to the set of all defined commands. Don't provide
51763820 5183 any initial input. Save the command read on the extended-command
03b4122a 5184 history list. */
284f4730
JB
5185 function = Fcompleting_read (build_string (buf),
5186 Vobarray, Qcommandp,
03b4122a 5187 Qt, Qnil, Qextended_command_history);
284f4730 5188
1113d9db
JB
5189 /* Set this_command_keys to the concatenation of saved_keys and
5190 function, followed by a RET. */
284f4730 5191 {
1113d9db 5192 struct Lisp_String *str;
b0f2a7bf 5193 Lisp_Object *keys;
284f4730
JB
5194 int i;
5195 Lisp_Object tem;
5196
1113d9db
JB
5197 this_command_key_count = 0;
5198
b0f2a7bf
KH
5199 keys = XVECTOR (saved_keys)->contents;
5200 for (i = 0; i < XVECTOR (saved_keys)->size; i++)
5201 add_command_key (keys[i]);
1113d9db
JB
5202
5203 str = XSTRING (function);
5204 for (i = 0; i < str->size; i++)
5205 {
5206 XFASTINT (tem) = str->data[i];
5207 add_command_key (tem);
5208 }
5209
5210 XFASTINT (tem) = '\015';
5211 add_command_key (tem);
284f4730
JB
5212 }
5213
5214 UNGCPRO;
5215
0a7f1fc0 5216 function = Fintern (function, Qnil);
284f4730
JB
5217 Vprefix_arg = prefixarg;
5218 this_command = function;
5219
5220 return Fcommand_execute (function, Qt);
5221}
5222\f
5223
5224detect_input_pending ()
5225{
5226 if (!input_pending)
5227 get_input_pending (&input_pending);
5228
5229 return input_pending;
5230}
5231
ffd56f97
JB
5232/* This is called in some cases before a possible quit.
5233 It cases the next call to detect_input_pending to recompute input_pending.
5234 So calling this function unnecessarily can't do any harm. */
5235clear_input_pending ()
5236{
5237 input_pending = 0;
5238}
5239
284f4730
JB
5240DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
5241 "T if command input is currently available with no waiting.\n\
5242Actually, the value is nil only if we can be sure that no input is available.")
5243 ()
5244{
24597608 5245 if (!NILP (Vunread_command_events) || unread_command_char != -1)
284f4730
JB
5246 return (Qt);
5247
5248 return detect_input_pending () ? Qt : Qnil;
5249}
5250
5251DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
22d7cb89 5252 "Return vector of last 100 events, not counting those from keyboard macros.")
284f4730
JB
5253 ()
5254{
5160df46 5255 Lisp_Object *keys = XVECTOR (recent_keys)->contents;
284f4730
JB
5256 Lisp_Object val;
5257
5258 if (total_keys < NUM_RECENT_KEYS)
5160df46 5259 return Fvector (total_keys, keys);
284f4730
JB
5260 else
5261 {
5160df46
JB
5262 val = Fvector (NUM_RECENT_KEYS, keys);
5263 bcopy (keys + recent_keys_index,
284f4730
JB
5264 XVECTOR (val)->contents,
5265 (NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
5160df46 5266 bcopy (keys,
284f4730
JB
5267 XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
5268 recent_keys_index * sizeof (Lisp_Object));
5269 return val;
5270 }
5271}
5272
5273DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
e5f920d7
RS
5274 "Return the key sequence that invoked this command.\n\
5275The value is a string or a vector.")
284f4730
JB
5276 ()
5277{
86e5706b
RS
5278 return make_event_array (this_command_key_count,
5279 XVECTOR (this_command_keys)->contents);
284f4730
JB
5280}
5281
5282DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
5283 "Return the current depth in recursive edits.")
5284 ()
5285{
5286 Lisp_Object temp;
5287 XFASTINT (temp) = command_loop_level + minibuf_level;
5288 return temp;
5289}
5290
5291DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
5292 "FOpen dribble file: ",
9b2471df
RS
5293 "Start writing all keyboard characters to a dribble file called FILE.\n\
5294If FILE is nil, close any open dribble file.")
284f4730
JB
5295 (file)
5296 Lisp_Object file;
5297{
5298 if (NILP (file))
5299 {
5300 fclose (dribble);
5301 dribble = 0;
5302 }
5303 else
5304 {
5305 file = Fexpand_file_name (file, Qnil);
5306 dribble = fopen (XSTRING (file)->data, "w");
5307 }
5308 return Qnil;
5309}
5310
5311DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
5312 "Discard the contents of the terminal input buffer.\n\
5313Also cancel any kbd macro being defined.")
5314 ()
5315{
5316 defining_kbd_macro = 0;
5317 update_mode_lines++;
5318
24597608 5319 Vunread_command_events = Qnil;
86e5706b 5320 unread_command_char = -1;
284f4730
JB
5321
5322 discard_tty_input ();
5323
ff0b5f4c
JB
5324 /* Without the cast, GCC complains that this assignment loses the
5325 volatile qualifier of kbd_store_ptr. Is there anything wrong
5326 with that? */
5327 kbd_fetch_ptr = (struct input_event *) kbd_store_ptr;
7b4aedb9 5328 Ffillarray (kbd_buffer_frame_or_window, Qnil);
284f4730
JB
5329 input_pending = 0;
5330
5331 return Qnil;
5332}
5333\f
5334DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
5335 "Stop Emacs and return to superior process. You can resume later.\n\
8026024c
KH
5336If `cannot-suspend' is non-nil, or if the system doesn't support job\n\
5337control, run a subshell instead.\n\n\
284f4730 5338If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
b7d2ebbf
RS
5339to be read as terminal input by Emacs's parent, after suspension.\n\
5340\n\
7df30614 5341Before suspending, call the functions in `suspend-hook' with no args.\n\
b7d2ebbf
RS
5342If any of them returns nil, don't call the rest and don't suspend.\n\
5343Otherwise, suspend normally and after resumption run the normal hook\n\
284f4730
JB
5344`suspend-resume-hook' if that is bound and non-nil.\n\
5345\n\
5346Some operating systems cannot stop the Emacs process and resume it later.\n\
b7d2ebbf 5347On such systems, Emacs starts a subshell instead of suspending.")
284f4730
JB
5348 (stuffstring)
5349 Lisp_Object stuffstring;
5350{
3a69360c 5351 Lisp_Object tem;
284f4730
JB
5352 int count = specpdl_ptr - specpdl;
5353 int old_height, old_width;
5354 int width, height;
b7d2ebbf 5355 struct gcpro gcpro1, gcpro2;
284f4730
JB
5356 extern init_sys_modes ();
5357
5358 if (!NILP (stuffstring))
5359 CHECK_STRING (stuffstring, 0);
284f4730 5360
1e95ed28
JB
5361 /* Run the functions in suspend-hook. */
5362 if (!NILP (Vrun_hooks))
5363 call1 (Vrun_hooks, intern ("suspend-hook"));
284f4730 5364
b7d2ebbf 5365 GCPRO1 (stuffstring);
ff11dfa1 5366 get_frame_size (&old_width, &old_height);
284f4730
JB
5367 reset_sys_modes ();
5368 /* sys_suspend can get an error if it tries to fork a subshell
5369 and the system resources aren't available for that. */
5370 record_unwind_protect (init_sys_modes, 0);
5371 stuff_buffered_input (stuffstring);
8026024c
KH
5372 if (cannot_suspend)
5373 sys_subshell ();
5374 else
5375 sys_suspend ();
284f4730
JB
5376 unbind_to (count, Qnil);
5377
5378 /* Check if terminal/window size has changed.
5379 Note that this is not useful when we are running directly
5380 with a window system; but suspend should be disabled in that case. */
ff11dfa1 5381 get_frame_size (&width, &height);
284f4730 5382 if (width != old_width || height != old_height)
f5ea6163 5383 change_frame_size (selected_frame, height, width, 0, 0);
284f4730 5384
1e95ed28 5385 /* Run suspend-resume-hook. */
284f4730
JB
5386 if (!NILP (Vrun_hooks))
5387 call1 (Vrun_hooks, intern ("suspend-resume-hook"));
5388
5389 UNGCPRO;
5390 return Qnil;
5391}
5392
5393/* If STUFFSTRING is a string, stuff its contents as pending terminal input.
eb8c3be9 5394 Then in any case stuff anything Emacs has read ahead and not used. */
284f4730
JB
5395
5396stuff_buffered_input (stuffstring)
5397 Lisp_Object stuffstring;
5398{
5399 register unsigned char *p;
5400
5401/* stuff_char works only in BSD, versions 4.2 and up. */
5402#ifdef BSD
5403#ifndef BSD4_1
5404 if (XTYPE (stuffstring) == Lisp_String)
5405 {
5406 register int count;
5407
5408 p = XSTRING (stuffstring)->data;
5409 count = XSTRING (stuffstring)->size;
5410 while (count-- > 0)
5411 stuff_char (*p++);
5412 stuff_char ('\n');
5413 }
5414 /* Anything we have read ahead, put back for the shell to read. */
5415 while (kbd_fetch_ptr != kbd_store_ptr)
5416 {
5417 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
5418 kbd_fetch_ptr = kbd_buffer;
5419 if (kbd_fetch_ptr->kind == ascii_keystroke)
e9bf89a0 5420 stuff_char (kbd_fetch_ptr->code);
4bb994d1 5421 kbd_fetch_ptr->kind = no_event;
7b4aedb9
JB
5422 (XVECTOR (kbd_buffer_frame_or_window)->contents[kbd_fetch_ptr
5423 - kbd_buffer]
5424 = Qnil);
284f4730
JB
5425 kbd_fetch_ptr++;
5426 }
5427 input_pending = 0;
5428#endif
5429#endif /* BSD and not BSD4_1 */
5430}
5431\f
ffd56f97
JB
5432set_waiting_for_input (time_to_clear)
5433 EMACS_TIME *time_to_clear;
284f4730 5434{
ffd56f97 5435 input_available_clear_time = time_to_clear;
284f4730
JB
5436
5437 /* Tell interrupt_signal to throw back to read_char, */
5438 waiting_for_input = 1;
5439
5440 /* If interrupt_signal was called before and buffered a C-g,
5441 make it run again now, to avoid timing error. */
5442 if (!NILP (Vquit_flag))
5443 quit_throw_to_read_char ();
284f4730
JB
5444}
5445
5446clear_waiting_for_input ()
5447{
5448 /* Tell interrupt_signal not to throw back to read_char, */
5449 waiting_for_input = 0;
ffd56f97 5450 input_available_clear_time = 0;
284f4730
JB
5451}
5452
5453/* This routine is called at interrupt level in response to C-G.
5454 If interrupt_input, this is the handler for SIGINT.
5455 Otherwise, it is called from kbd_buffer_store_event,
5456 in handling SIGIO or SIGTINT.
5457
5458 If `waiting_for_input' is non zero, then unless `echoing' is nonzero,
5459 immediately throw back to read_char.
5460
5461 Otherwise it sets the Lisp variable quit-flag not-nil.
5462 This causes eval to throw, when it gets a chance.
5463 If quit-flag is already non-nil, it stops the job right away. */
5464
5465SIGTYPE
5466interrupt_signal ()
5467{
5468 char c;
5469 /* Must preserve main program's value of errno. */
5470 int old_errno = errno;
284f4730
JB
5471
5472#ifdef USG
5473 /* USG systems forget handlers when they are used;
5474 must reestablish each time */
5475 signal (SIGINT, interrupt_signal);
5476 signal (SIGQUIT, interrupt_signal);
5477#endif /* USG */
5478
5479 cancel_echoing ();
5480
d5045cf9 5481 if (!NILP (Vquit_flag) && FRAME_TERMCAP_P (selected_frame))
284f4730
JB
5482 {
5483 fflush (stdout);
5484 reset_sys_modes ();
5485 sigfree ();
5486#ifdef SIGTSTP /* Support possible in later USG versions */
5487/*
5488 * On systems which can suspend the current process and return to the original
5489 * shell, this command causes the user to end up back at the shell.
5490 * The "Auto-save" and "Abort" questions are not asked until
5491 * the user elects to return to emacs, at which point he can save the current
5492 * job and either dump core or continue.
5493 */
5494 sys_suspend ();
5495#else
5496#ifdef VMS
5497 if (sys_suspend () == -1)
5498 {
5499 printf ("Not running as a subprocess;\n");
5500 printf ("you can continue or abort.\n");
5501 }
5502#else /* not VMS */
5503 /* Perhaps should really fork an inferior shell?
5504 But that would not provide any way to get back
5505 to the original shell, ever. */
5506 printf ("No support for stopping a process on this operating system;\n");
5507 printf ("you can continue or abort.\n");
5508#endif /* not VMS */
5509#endif /* not SIGTSTP */
80e4aa30
RS
5510#ifdef MSDOS
5511 /* We must remain inside the screen area when the internal terminal
5512 is used. Note that [Enter] is not echoed by dos. */
5513 cursor_to (0, 0);
5514#endif
284f4730
JB
5515 printf ("Auto-save? (y or n) ");
5516 fflush (stdout);
5517 if (((c = getchar ()) & ~040) == 'Y')
9fd7d808
RS
5518 {
5519 Fdo_auto_save (Qt, Qnil);
80e4aa30
RS
5520#ifdef MSDOS
5521 printf ("\r\nAuto-save done");
5522#else /* not MSDOS */
9fd7d808 5523 printf ("Auto-save done\n");
80e4aa30 5524#endif /* not MSDOS */
9fd7d808 5525 }
284f4730 5526 while (c != '\n') c = getchar ();
80e4aa30
RS
5527#ifdef MSDOS
5528 printf ("\r\nAbort? (y or n) ");
5529#else /* not MSDOS */
284f4730
JB
5530#ifdef VMS
5531 printf ("Abort (and enter debugger)? (y or n) ");
5532#else /* not VMS */
5533 printf ("Abort (and dump core)? (y or n) ");
5534#endif /* not VMS */
80e4aa30 5535#endif /* not MSDOS */
284f4730
JB
5536 fflush (stdout);
5537 if (((c = getchar ()) & ~040) == 'Y')
5538 abort ();
5539 while (c != '\n') c = getchar ();
80e4aa30
RS
5540#ifdef MSDOS
5541 printf ("\r\nContinuing...\r\n");
5542#else /* not MSDOS */
284f4730 5543 printf ("Continuing...\n");
80e4aa30 5544#endif /* not MSDOS */
284f4730
JB
5545 fflush (stdout);
5546 init_sys_modes ();
5547 }
5548 else
5549 {
5550 /* If executing a function that wants to be interrupted out of
5551 and the user has not deferred quitting by binding `inhibit-quit'
5552 then quit right away. */
5553 if (immediate_quit && NILP (Vinhibit_quit))
5554 {
5555 immediate_quit = 0;
5556 sigfree ();
5557 Fsignal (Qquit, Qnil);
5558 }
5559 else
5560 /* Else request quit when it's safe */
5561 Vquit_flag = Qt;
5562 }
5563
5564 if (waiting_for_input && !echoing)
5565 quit_throw_to_read_char ();
5566
5567 errno = old_errno;
5568}
5569
5570/* Handle a C-g by making read_char return C-g. */
5571
5572quit_throw_to_read_char ()
5573{
5574 quit_error_check ();
5575 sigfree ();
5576 /* Prevent another signal from doing this before we finish. */
f76475ad 5577 clear_waiting_for_input ();
284f4730
JB
5578 input_pending = 0;
5579
24597608 5580 Vunread_command_events = Qnil;
86e5706b 5581 unread_command_char = -1;
284f4730 5582
e6b01c14
JB
5583#ifdef POLL_FOR_INPUT
5584 /* May be > 1 if in recursive minibuffer. */
5585 if (poll_suppress_count == 0)
5586 abort ();
5587#endif
0dfcc832 5588#ifdef MULTI_FRAME
e9bf89a0
RS
5589 if (XTYPE (internal_last_event_frame) == Lisp_Frame
5590 && XFRAME (internal_last_event_frame) != selected_frame)
3b9189f8 5591 Fhandle_switch_frame (make_lispy_switch_frame (internal_last_event_frame));
0dfcc832 5592#endif
e6b01c14 5593
284f4730
JB
5594 _longjmp (getcjmp, 1);
5595}
5596\f
5597DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
5598 "Set mode of reading keyboard input.\n\
464f8898
RS
5599First arg INTERRUPT non-nil means use input interrupts;\n\
5600 nil means use CBREAK mode.\n\
5601Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal\n\
284f4730 5602 (no effect except in CBREAK mode).\n\
b04904fb
RS
5603Third arg META t means accept 8-bit input (for a Meta key).\n\
5604 META nil means ignore the top bit, on the assumption it is parity.\n\
5605 Otherwise, accept 8-bit input and don't use the top bit for Meta.\n\
a8ee7ef9
RS
5606Optional fourth arg QUIT if non-nil specifies character to use for quitting.\n\
5607See also `current-input-mode'.")
284f4730
JB
5608 (interrupt, flow, meta, quit)
5609 Lisp_Object interrupt, flow, meta, quit;
5610{
5611 if (!NILP (quit)
5612 && (XTYPE (quit) != Lisp_Int
5613 || XINT (quit) < 0 || XINT (quit) > 0400))
34f04431
RS
5614 error ("set-input-mode: QUIT must be an ASCII character");
5615
5616#ifdef POLL_FOR_INPUT
5617 stop_polling ();
5618#endif
284f4730
JB
5619
5620 reset_sys_modes ();
5621#ifdef SIGIO
5622/* Note SIGIO has been undef'd if FIONREAD is missing. */
5623#ifdef NO_SOCK_SIGIO
5624 if (read_socket_hook)
5625 interrupt_input = 0; /* No interrupts if reading from a socket. */
5626 else
5627#endif /* NO_SOCK_SIGIO */
5628 interrupt_input = !NILP (interrupt);
5629#else /* not SIGIO */
5630 interrupt_input = 0;
5631#endif /* not SIGIO */
5632/* Our VMS input only works by interrupts, as of now. */
5633#ifdef VMS
5634 interrupt_input = 1;
5635#endif
5636 flow_control = !NILP (flow);
b04904fb
RS
5637 if (NILP (meta))
5638 meta_key = 0;
5639 else if (EQ (meta, Qt))
5640 meta_key = 1;
5641 else
5642 meta_key = 2;
284f4730
JB
5643 if (!NILP (quit))
5644 /* Don't let this value be out of range. */
5645 quit_char = XINT (quit) & (meta_key ? 0377 : 0177);
5646
5647 init_sys_modes ();
34f04431
RS
5648
5649#ifdef POLL_FOR_INPUT
5650 poll_suppress_count = 1;
5651 start_polling ();
5652#endif
284f4730
JB
5653 return Qnil;
5654}
80645119
JB
5655
5656DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
5657 "Return information about the way Emacs currently reads keyboard input.\n\
5658The value is a list of the form (INTERRUPT FLOW META QUIT), where\n\
5659 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if\n\
5660 nil, Emacs is using CBREAK mode.\n\
5661 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the\n\
5662 terminal; this does not apply if Emacs uses interrupt-driven input.\n\
a8ee7ef9
RS
5663 META is t if accepting 8-bit input with 8th bit as Meta flag.\n\
5664 META nil means ignoring the top bit, on the assumption it is parity.\n\
5665 META is neither t nor nil if accepting 8-bit input and using\n\
5666 all 8 bits as the character code.\n\
80645119
JB
5667 QUIT is the character Emacs currently uses to quit.\n\
5668The elements of this list correspond to the arguments of\n\
a8ee7ef9 5669`set-input-mode'.")
80645119
JB
5670 ()
5671{
5672 Lisp_Object val[4];
5673
5674 val[0] = interrupt_input ? Qt : Qnil;
5675 val[1] = flow_control ? Qt : Qnil;
a8ee7ef9 5676 val[2] = meta_key == 2 ? make_number (0) : meta_key == 1 ? Qt : Qnil;
7b50ece7 5677 XFASTINT (val[3]) = quit_char;
80645119 5678
bf673a7a 5679 return Flist (sizeof (val) / sizeof (val[0]), val);
80645119
JB
5680}
5681
284f4730
JB
5682\f
5683init_keyboard ()
5684{
284f4730
JB
5685 /* This is correct before outermost invocation of the editor loop */
5686 command_loop_level = -1;
5687 immediate_quit = 0;
5688 quit_char = Ctl ('g');
24597608 5689 Vunread_command_events = Qnil;
86e5706b 5690 unread_command_char = -1;
284f4730 5691 total_keys = 0;
9deb415a 5692 recent_keys_index = 0;
284f4730
JB
5693 kbd_fetch_ptr = kbd_buffer;
5694 kbd_store_ptr = kbd_buffer;
5695 do_mouse_tracking = 0;
5696 input_pending = 0;
5697
07d2b8de 5698#ifdef MULTI_FRAME
8f805655
JB
5699 /* This means that command_loop_1 won't try to select anything the first
5700 time through. */
3c370943
JB
5701 internal_last_event_frame = Qnil;
5702 Vlast_event_frame = internal_last_event_frame;
7b4aedb9
JB
5703#endif
5704
5705 /* If we're running a dumped Emacs, we need to clear out
5706 kbd_buffer_frame_or_window, in case some events got into it
5707 before we dumped.
4bb994d1 5708
7b4aedb9
JB
5709 If we're running an undumped Emacs, it hasn't been initialized by
5710 syms_of_keyboard yet. */
4bb994d1 5711 if (initialized)
7b4aedb9 5712 Ffillarray (kbd_buffer_frame_or_window, Qnil);
07d2b8de 5713
284f4730
JB
5714 if (!noninteractive)
5715 {
5716 signal (SIGINT, interrupt_signal);
cb5df6ae 5717#if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
284f4730
JB
5718 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
5719 SIGQUIT and we can't tell which one it will give us. */
5720 signal (SIGQUIT, interrupt_signal);
5721#endif /* HAVE_TERMIO */
5722/* Note SIGIO has been undef'd if FIONREAD is missing. */
5723#ifdef SIGIO
5724 signal (SIGIO, input_available_signal);
8ea0a720 5725#endif /* SIGIO */
284f4730
JB
5726 }
5727
5728/* Use interrupt input by default, if it works and noninterrupt input
5729 has deficiencies. */
5730
5731#ifdef INTERRUPT_INPUT
5732 interrupt_input = 1;
5733#else
5734 interrupt_input = 0;
5735#endif
5736
5737/* Our VMS input only works by interrupts, as of now. */
5738#ifdef VMS
5739 interrupt_input = 1;
5740#endif
5741
5742 sigfree ();
5743 dribble = 0;
5744
5745 if (keyboard_init_hook)
5746 (*keyboard_init_hook) ();
5747
5748#ifdef POLL_FOR_INPUT
5749 poll_suppress_count = 1;
5750 start_polling ();
5751#endif
5752}
5753
5754/* This type's only use is in syms_of_keyboard, to initialize the
5755 event header symbols and put properties on them. */
5756struct event_head {
5757 Lisp_Object *var;
5758 char *name;
5759 Lisp_Object *kind;
5760};
5761
5762struct event_head head_table[] = {
7b4aedb9 5763 &Qmouse_movement, "mouse-movement", &Qmouse_movement,
3c370943 5764 &Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement,
7b4aedb9 5765 &Qswitch_frame, "switch-frame", &Qswitch_frame,
284f4730
JB
5766};
5767
5768syms_of_keyboard ()
5769{
2e894dab
RS
5770 Qdisabled_command_hook = intern ("disabled-command-hook");
5771 staticpro (&Qdisabled_command_hook);
5772
284f4730
JB
5773 Qself_insert_command = intern ("self-insert-command");
5774 staticpro (&Qself_insert_command);
5775
5776 Qforward_char = intern ("forward-char");
5777 staticpro (&Qforward_char);
5778
5779 Qbackward_char = intern ("backward-char");
5780 staticpro (&Qbackward_char);
5781
5782 Qdisabled = intern ("disabled");
5783 staticpro (&Qdisabled);
5784
e58aa385
RS
5785 Qundefined = intern ("undefined");
5786 staticpro (&Qundefined);
5787
86e5706b
RS
5788 Qpre_command_hook = intern ("pre-command-hook");
5789 staticpro (&Qpre_command_hook);
5790
5791 Qpost_command_hook = intern ("post-command-hook");
5792 staticpro (&Qpost_command_hook);
5793
40932d1a
RS
5794 Qcommand_hook_internal = intern ("command-hook-internal");
5795 staticpro (&Qcommand_hook_internal);
5796
284f4730
JB
5797 Qfunction_key = intern ("function-key");
5798 staticpro (&Qfunction_key);
13b5e56c 5799 Qmouse_click = intern ("mouse-click");
284f4730 5800 staticpro (&Qmouse_click);
284f4730 5801
598a9fa7
JB
5802 Qmenu_enable = intern ("menu-enable");
5803 staticpro (&Qmenu_enable);
5804
284f4730
JB
5805 Qmode_line = intern ("mode-line");
5806 staticpro (&Qmode_line);
e5d77022
JB
5807 Qvertical_line = intern ("vertical-line");
5808 staticpro (&Qvertical_line);
3c370943
JB
5809 Qvertical_scroll_bar = intern ("vertical-scroll-bar");
5810 staticpro (&Qvertical_scroll_bar);
5ec75a55
RS
5811 Qmenu_bar = intern ("menu-bar");
5812 staticpro (&Qmenu_bar);
4bb994d1
JB
5813
5814 Qabove_handle = intern ("above-handle");
5815 staticpro (&Qabove_handle);
5816 Qhandle = intern ("handle");
5817 staticpro (&Qhandle);
5818 Qbelow_handle = intern ("below-handle");
5819 staticpro (&Qbelow_handle);
284f4730 5820
cd21b839 5821 Qevent_kind = intern ("event-kind");
284f4730 5822 staticpro (&Qevent_kind);
88cb0656
JB
5823 Qevent_symbol_elements = intern ("event-symbol-elements");
5824 staticpro (&Qevent_symbol_elements);
0a7f1fc0
JB
5825 Qevent_symbol_element_mask = intern ("event-symbol-element-mask");
5826 staticpro (&Qevent_symbol_element_mask);
5827 Qmodifier_cache = intern ("modifier-cache");
5828 staticpro (&Qmodifier_cache);
284f4730 5829
48e416d4
RS
5830 Qrecompute_lucid_menubar = intern ("recompute-lucid-menubar");
5831 staticpro (&Qrecompute_lucid_menubar);
5832 Qactivate_menubar_hook = intern ("activate-menubar-hook");
5833 staticpro (&Qactivate_menubar_hook);
5834
284f4730
JB
5835 {
5836 struct event_head *p;
5837
5838 for (p = head_table;
5839 p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
5840 p++)
5841 {
5842 *p->var = intern (p->name);
5843 staticpro (p->var);
5844 Fput (*p->var, Qevent_kind, *p->kind);
88cb0656 5845 Fput (*p->var, Qevent_symbol_elements, Fcons (*p->var, Qnil));
284f4730
JB
5846 }
5847 }
5848
7b4aedb9
JB
5849 button_down_location = Fmake_vector (make_number (NUM_MOUSE_BUTTONS), Qnil);
5850 staticpro (&button_down_location);
88cb0656
JB
5851
5852 {
5853 int i;
5854 int len = sizeof (modifier_names) / sizeof (modifier_names[0]);
5855
5856 modifier_symbols = Fmake_vector (make_number (len), Qnil);
5857 for (i = 0; i < len; i++)
86e5706b
RS
5858 if (modifier_names[i])
5859 XVECTOR (modifier_symbols)->contents[i] = intern (modifier_names[i]);
88cb0656
JB
5860 staticpro (&modifier_symbols);
5861 }
5862
9deb415a
JB
5863 recent_keys = Fmake_vector (make_number (NUM_RECENT_KEYS), Qnil);
5864 staticpro (&recent_keys);
5865
6569cc8d 5866 this_command_keys = Fmake_vector (make_number (40), Qnil);
715d9345 5867 staticpro (&this_command_keys);
6569cc8d 5868
03b4122a
BF
5869 Qextended_command_history = intern ("extended-command-history");
5870 Fset (Qextended_command_history, Qnil);
5871 staticpro (&Qextended_command_history);
5872
7b4aedb9
JB
5873 kbd_buffer_frame_or_window
5874 = Fmake_vector (make_number (KBD_BUFFER_SIZE), Qnil);
5875 staticpro (&kbd_buffer_frame_or_window);
4bb994d1 5876
24597608
RS
5877 accent_key_syms = Qnil;
5878 staticpro (&accent_key_syms);
5879
284f4730
JB
5880 func_key_syms = Qnil;
5881 staticpro (&func_key_syms);
5882
4e0e7d8e
RS
5883 system_key_syms = Qnil;
5884 staticpro (&system_key_syms);
5885
284f4730
JB
5886 mouse_syms = Qnil;
5887 staticpro (&mouse_syms);
5888
cd21b839
JB
5889 unread_switch_frame = Qnil;
5890 staticpro (&unread_switch_frame);
5891
284f4730
JB
5892 defsubr (&Sread_key_sequence);
5893 defsubr (&Srecursive_edit);
5894 defsubr (&Strack_mouse);
284f4730
JB
5895 defsubr (&Sinput_pending_p);
5896 defsubr (&Scommand_execute);
5897 defsubr (&Srecent_keys);
5898 defsubr (&Sthis_command_keys);
5899 defsubr (&Ssuspend_emacs);
5900 defsubr (&Sabort_recursive_edit);
5901 defsubr (&Sexit_recursive_edit);
5902 defsubr (&Srecursion_depth);
5903 defsubr (&Stop_level);
5904 defsubr (&Sdiscard_input);
5905 defsubr (&Sopen_dribble_file);
5906 defsubr (&Sset_input_mode);
80645119 5907 defsubr (&Scurrent_input_mode);
284f4730
JB
5908 defsubr (&Sexecute_extended_command);
5909
284f4730 5910 DEFVAR_LISP ("last-command-char", &last_command_char,
86e5706b
RS
5911 "Last input event that was part of a command.");
5912
5913 DEFVAR_LISP ("last-command-event", &last_command_char,
5914 "Last input event that was part of a command.");
284f4730 5915
7d6de002 5916 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
86e5706b 5917 "Last input event in a command, except for mouse menu events.\n\
7d6de002
RS
5918Mouse menus give back keys that don't look like mouse events;\n\
5919this variable holds the actual mouse event that led to the menu,\n\
5920so that you can determine whether the command was run by mouse or not.");
5921
284f4730 5922 DEFVAR_LISP ("last-input-char", &last_input_char,
86e5706b
RS
5923 "Last input event.");
5924
5925 DEFVAR_LISP ("last-input-event", &last_input_char,
5926 "Last input event.");
284f4730 5927
24597608 5928 DEFVAR_LISP ("unread-command-events", &Vunread_command_events,
1c07d0a6 5929 "List of objects to be read as next command input events.");
284f4730 5930
86e5706b
RS
5931 DEFVAR_INT ("unread-command-char", &unread_command_char,
5932 "If not -1, an object to be read as next command input event.");
5933
284f4730
JB
5934 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char,
5935 "Meta-prefix character code. Meta-foo as command input\n\
5936turns into this character followed by foo.");
5937 XSET (meta_prefix_char, Lisp_Int, 033);
5938
5939 DEFVAR_LISP ("last-command", &last_command,
5940 "The last command executed. Normally a symbol with a function definition,\n\
5941but can be whatever was found in the keymap, or whatever the variable\n\
5942`this-command' was set to by that command.");
5943 last_command = Qnil;
5944
5945 DEFVAR_LISP ("this-command", &this_command,
5946 "The command now being executed.\n\
5947The command can set this variable; whatever is put here\n\
5948will be in `last-command' during the following command.");
5949 this_command = Qnil;
5950
5951 DEFVAR_INT ("auto-save-interval", &auto_save_interval,
5952 "*Number of keyboard input characters between auto-saves.\n\
5953Zero means disable autosaving due to number of characters typed.");
5954 auto_save_interval = 300;
5955
5956 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout,
5957 "*Number of seconds idle time before auto-save.\n\
06ef7355
RS
5958Zero or nil means disable auto-saving due to idleness.\n\
5959After auto-saving due to this many seconds of idle time,\n\
84447c71 5960Emacs also does a garbage collection if that seems to be warranted.");
284f4730
JB
5961 XFASTINT (Vauto_save_timeout) = 30;
5962
5963 DEFVAR_INT ("echo-keystrokes", &echo_keystrokes,
5964 "*Nonzero means echo unfinished commands after this many seconds of pause.");
5965 echo_keystrokes = 1;
5966
5967 DEFVAR_INT ("polling-period", &polling_period,
5968 "*Interval between polling for input during Lisp execution.\n\
5969The reason for polling is to make C-g work to stop a running program.\n\
5970Polling is needed only when using X windows and SIGIO does not work.\n\
5971Polling is automatically disabled in all other cases.");
5972 polling_period = 2;
5973
564dc952 5974 DEFVAR_LISP ("double-click-time", &Vdouble_click_time,
fbcd35bd 5975 "*Maximum time between mouse clicks to make a double-click.\n\
564dc952
JB
5976Measured in milliseconds. nil means disable double-click recognition;\n\
5977t means double-clicks have no time limit and are detected\n\
fbcd35bd 5978by position only.");
aab06933 5979 Vdouble_click_time = make_number (500);
fbcd35bd 5980
284f4730
JB
5981 DEFVAR_INT ("num-input-keys", &num_input_keys,
5982 "*Number of complete keys read from the keyboard so far.");
5983 num_input_keys = 0;
5984
ff11dfa1 5985 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
fce33686
JB
5986 "*The frame in which the most recently read event occurred.\n\
5987If the last event came from a keyboard macro, this is set to `macro'.");
ff11dfa1 5988 Vlast_event_frame = Qnil;
284f4730 5989
7e85b935 5990 DEFVAR_LISP ("help-char", &Vhelp_char,
284f4730
JB
5991 "Character to recognize as meaning Help.\n\
5992When it is read, do `(eval help-form)', and display result if it's a string.\n\
5993If the value of `help-form' is nil, this char can be read normally.");
7e85b935 5994 XSET (Vhelp_char, Lisp_Int, Ctl ('H'));
284f4730
JB
5995
5996 DEFVAR_LISP ("help-form", &Vhelp_form,
7e85b935 5997 "Form to execute when character `help-char' is read.\n\
284f4730
JB
5998If the form returns a string, that string is displayed.\n\
5999If `help-form' is nil, the help char is not recognized.");
6000 Vhelp_form = Qnil;
6001
7e85b935
RS
6002 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command,
6003 "Command to run when `help-char' character follows a prefix key.\n\
6004This command is used only when there is no actual binding\n\
6005for that character after that prefix key.");
6006 Vprefix_help_command = Qnil;
6007
284f4730
JB
6008 DEFVAR_LISP ("top-level", &Vtop_level,
6009 "Form to evaluate when Emacs starts up.\n\
6010Useful to set before you dump a modified Emacs.");
6011 Vtop_level = Qnil;
6012
6013 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table,
6014 "String used as translate table for keyboard input, or nil.\n\
6015Each character is looked up in this string and the contents used instead.\n\
6016If string is of length N, character codes N and up are untranslated.");
6017 Vkeyboard_translate_table = Qnil;
6018
a612e298
RS
6019 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map,
6020 "Keymap of key translations that can override keymaps.\n\
6021This keymap works like `function-key-map', but comes after that,\n\
6022and applies even for keys that have ordinary bindings.");
6023 Vkey_translation_map = Qnil;
6024
8026024c
KH
6025 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
6026 "Non-nil means to always spawn a subshell instead of suspending,\n\
6027even if the operating system has support for stopping a process.");
6028 cannot_suspend = 0;
6029
284f4730 6030 DEFVAR_BOOL ("menu-prompting", &menu_prompting,
7d6de002 6031 "Non-nil means prompt with menus when appropriate.\n\
284f4730 6032This is done when reading from a keymap that has a prompt string,\n\
7d6de002
RS
6033for elements that have prompt strings.\n\
6034The menu is displayed on the screen\n\
6035if X menus were enabled at configuration\n\
6036time and the previous event was a mouse click prefix key.\n\
6037Otherwise, menu prompting uses the echo area.");
284f4730
JB
6038 menu_prompting = 1;
6039
6040 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,
6041 "Character to see next line of menu prompt.\n\
6042Type this character while in a menu prompt to rotate around the lines of it.");
6043 XSET (menu_prompt_more_char, Lisp_Int, ' ');
9fa4395d
RS
6044
6045 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers,
6046 "A mask of additional modifier keys to use with every keyboard character.\n\
ad163903
JB
6047Emacs applies the modifiers of the character stored here to each keyboard\n\
6048character it reads. For example, after evaluating the expression\n\
80645119
JB
6049 (setq extra-keyboard-modifiers ?\C-x)\n\
6050all input characters will have the control modifier applied to them.\n\
6051\n\
6052Note that the character ?\C-@, equivalent to the integer zero, does\n\
6053not count as a control character; rather, it counts as a character\n\
27203ead 6054with no modifiers; thus, setting `extra-keyboard-modifiers' to zero\n\
80645119 6055cancels any modification.");
9fa4395d 6056 extra_keyboard_modifiers = 0;
86e5706b
RS
6057
6058 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark,
6059 "If an editing command sets this to t, deactivate the mark afterward.\n\
6060The command loop sets this to nil before each command,\n\
6061and tests the value when the command returns.\n\
6062Buffer modification stores t in this variable.");
6063 Vdeactivate_mark = Qnil;
6064
b0f2a7bf
KH
6065 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
6066 "Temporary storage of pre-command-hook or post-command-hook.");
6067 Vcommand_hook_internal = Qnil;
6068
86e5706b
RS
6069 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook,
6070 "Normal hook run before each command is executed.");
6071 Vpre_command_hook = Qnil;
6072
6073 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook,
7e85b935 6074 "Normal hook run after each command is executed.");
86e5706b 6075 Vpost_command_hook = Qnil;
48e416d4
RS
6076
6077 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag,
6078 "t means menu bar, specified Lucid style, needs to be recomputed.");
6079 Vlucid_menu_bar_dirty_flag = Qnil;
a73c5e29 6080
9f9c0e27
RS
6081 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items,
6082 "List of menu bar items to move to the end of the menu bar.\n\
a612e298 6083The elements of the list are event types that may have menu bar bindings.");
9f9c0e27 6084 Vmenu_bar_final_items = Qnil;
e9bf89a0 6085
9dd3131c
RS
6086 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
6087 "Keymap that overrides all other local keymaps.\n\
6088If this variable is non-nil, it is used as a keymap instead of the\n\
6089buffer's local map, and the minor mode keymaps and text property keymaps.");
6090 Voverriding_local_map = Qnil;
6091
e9bf89a0
RS
6092 DEFVAR_BOOL ("track-mouse", &do_mouse_tracking,
6093 "*Non-nil means generate motion events for mouse motion.");
80e4aa30 6094
270a208f
RS
6095 DEFVAR_LISP ("system-key-alist", &Vsystem_key_alist,
6096 "Alist of system-specific X windows key symbols.\n\
80e4aa30 6097Each element should have the form (N . SYMBOL) where N is the\n\
270a208f 6098numeric keysym code (sans the \"system-specific\" bit 1<<28)\n\
80e4aa30
RS
6099and SYMBOL is its name.");
6100 Vmenu_bar_final_items = Qnil;
284f4730
JB
6101}
6102
6103keys_of_keyboard ()
6104{
6105 initial_define_key (global_map, Ctl ('Z'), "suspend-emacs");
6106 initial_define_key (control_x_map, Ctl ('Z'), "suspend-emacs");
6107 initial_define_key (meta_map, Ctl ('C'), "exit-recursive-edit");
6108 initial_define_key (global_map, Ctl (']'), "abort-recursive-edit");
6109 initial_define_key (meta_map, 'x', "execute-extended-command");
6110}