1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95,96,97 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Allow config.h to undefine symbols found here. */
29 #include "termhooks.h"
37 #include "dispextern.h"
39 #include "intervals.h"
40 #include "blockinput.h"
49 #include <sys/ioctl.h>
51 #endif /* not MSDOS */
53 #include "syssignal.h"
56 /* This is to get the definitions of the XK_ symbols. */
63 #endif /* HAVE_NTGUI */
65 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
70 /* Variables for blockinput.h: */
72 /* Non-zero if interrupt input is blocked right now. */
73 int interrupt_input_blocked
;
75 /* Nonzero means an input interrupt has arrived
76 during the current critical section. */
77 int interrupt_input_pending
;
80 /* File descriptor to use for input. */
83 #ifdef HAVE_WINDOW_SYSTEM
84 /* Make all keyboard buffers much bigger when using X windows. */
85 #define KBD_BUFFER_SIZE 4096
86 #else /* No X-windows, character input */
87 #define KBD_BUFFER_SIZE 256
88 #endif /* No X-windows */
90 /* Following definition copied from eval.c */
94 struct backtrace
*next
;
95 Lisp_Object
*function
;
96 Lisp_Object
*args
; /* Points to vector of args. */
97 int nargs
; /* length of vector. If nargs is UNEVALLED,
98 args points to slot holding list of
104 KBOARD
*initial_kboard
;
105 KBOARD
*current_kboard
;
109 KBOARD the_only_kboard
;
112 /* Non-nil disable property on a command means
113 do not execute it; call disabled-command-hook's value instead. */
114 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
116 #define NUM_RECENT_KEYS (100)
117 int recent_keys_index
; /* Index for storing next element into recent_keys */
118 int total_keys
; /* Total number of elements stored into recent_keys */
119 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
121 /* Vector holding the key sequence that invoked the current command.
122 It is reused for each command, and it may be longer than the current
123 sequence; this_command_key_count indicates how many elements
124 actually mean something.
125 It's easier to staticpro a single Lisp_Object than an array. */
126 Lisp_Object this_command_keys
;
127 int this_command_key_count
;
129 /* Number of elements of this_command_keys
130 that precede this key sequence. */
131 int this_single_command_key_start
;
133 /* Record values of this_command_key_count and echo_length ()
134 before this command was read. */
135 static int before_command_key_count
;
136 static int before_command_echo_length
;
137 /* Values of before_command_key_count and before_command_echo_length
138 saved by reset-this-command-lengths. */
139 static int before_command_key_count_1
;
140 static int before_command_echo_length_1
;
141 /* Flag set by reset-this-command-lengths,
142 saying to reset the lengths when add_command_key is called. */
143 static int before_command_restore_flag
;
145 extern int minbuf_level
;
147 extern struct backtrace
*backtrace_list
;
149 /* Nonzero means do menu prompting. */
150 static int menu_prompting
;
152 /* Character to see next line of menu prompt. */
153 static Lisp_Object menu_prompt_more_char
;
155 /* For longjmp to where kbd input is being done. */
156 static jmp_buf getcjmp
;
158 /* True while doing kbd input. */
159 int waiting_for_input
;
161 /* True while displaying for echoing. Delays C-g throwing. */
164 /* True means we can start echoing at the next input pause
165 even though there is something in the echo area. */
166 static char *ok_to_echo_at_next_pause
;
168 /* Nonzero means disregard local maps for the menu bar. */
169 static int inhibit_local_menu_bar_menus
;
171 /* Nonzero means C-g should cause immediate error-signal. */
174 /* The user's ERASE setting. */
175 Lisp_Object Vtty_erase_char
;
177 /* Character to recognize as the help char. */
178 Lisp_Object Vhelp_char
;
180 /* List of other event types to recognize as meaning "help". */
181 Lisp_Object Vhelp_event_list
;
183 /* Form to execute when help char is typed. */
184 Lisp_Object Vhelp_form
;
186 /* Command to run when the help character follows a prefix key. */
187 Lisp_Object Vprefix_help_command
;
189 /* List of items that should move to the end of the menu bar. */
190 Lisp_Object Vmenu_bar_final_items
;
192 /* Non-nil means show the equivalent key-binding for
193 any M-x command that has one.
194 The value can be a length of time to show the message for.
195 If the value is non-nil and not a number, we wait 2 seconds. */
196 Lisp_Object Vsuggest_key_bindings
;
198 /* Character that causes a quit. Normally C-g.
200 If we are running on an ordinary terminal, this must be an ordinary
201 ASCII char, since we want to make it our interrupt character.
203 If we are not running on an ordinary terminal, it still needs to be
204 an ordinary ASCII char. This character needs to be recognized in
205 the input interrupt handler. At this point, the keystroke is
206 represented as a struct input_event, while the desired quit
207 character is specified as a lispy event. The mapping from struct
208 input_events to lispy events cannot run in an interrupt handler,
209 and the reverse mapping is difficult for anything but ASCII
212 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
216 extern Lisp_Object current_global_map
;
217 extern int minibuf_level
;
219 /* If non-nil, this is a map that overrides all other local maps. */
220 Lisp_Object Voverriding_local_map
;
222 /* If non-nil, Voverriding_local_map applies to the menu bar. */
223 Lisp_Object Voverriding_local_map_menu_flag
;
225 /* Keymap that defines special misc events that should
226 be processed immediately at a low level. */
227 Lisp_Object Vspecial_event_map
;
229 /* Current depth in recursive edits. */
230 int command_loop_level
;
232 /* Total number of times command_loop has read a key sequence. */
235 /* Last input character read as a command. */
236 Lisp_Object last_command_char
;
238 /* Last input character read as a command, not counting menus
239 reached by the mouse. */
240 Lisp_Object last_nonmenu_event
;
242 /* Last input character read for any purpose. */
243 Lisp_Object last_input_char
;
245 /* If not Qnil, a list of objects to be read as subsequent command input. */
246 Lisp_Object Vunread_command_events
;
248 /* If not -1, an event to be read as subsequent command input. */
249 int unread_command_char
;
251 /* If not Qnil, this is a switch-frame event which we decided to put
252 off until the end of a key sequence. This should be read as the
253 next command input, after any unread_command_events.
255 read_key_sequence uses this to delay switch-frame events until the
256 end of the key sequence; Fread_char uses it to put off switch-frame
257 events until a non-ASCII event is acceptable as input. */
258 Lisp_Object unread_switch_frame
;
260 /* A mask of extra modifier bits to put into every keyboard char. */
261 int extra_keyboard_modifiers
;
263 /* Char to use as prefix when a meta character is typed in.
264 This is bound on entry to minibuffer in case ESC is changed there. */
266 Lisp_Object meta_prefix_char
;
268 /* Last size recorded for a current buffer which is not a minibuffer. */
269 static int last_non_minibuf_size
;
271 /* Number of idle seconds before an auto-save and garbage collection. */
272 static Lisp_Object Vauto_save_timeout
;
274 /* Total number of times read_char has returned. */
275 int num_input_events
;
277 /* Total number of times read_char has returned, outside of macros. */
278 int num_nonmacro_input_events
;
280 /* Auto-save automatically when this many characters have been typed
281 since the last time. */
283 static int auto_save_interval
;
285 /* Value of num_nonmacro_input_events as of last auto save. */
289 /* The command being executed by the command loop.
290 Commands may set this, and the value set will be copied into
291 current_kboard->Vlast_command instead of the actual command. */
292 Lisp_Object this_command
;
294 /* The value of point when the last command was executed. */
295 int last_point_position
;
297 /* The buffer that was current when the last command was started. */
298 Lisp_Object last_point_position_buffer
;
300 /* The frame in which the last input event occurred, or Qmacro if the
301 last event came from a macro. We use this to determine when to
302 generate switch-frame events. This may be cleared by functions
303 like Fselect_frame, to make sure that a switch-frame event is
304 generated by the next character. */
305 Lisp_Object internal_last_event_frame
;
307 /* A user-visible version of the above, intended to allow users to
308 figure out where the last event came from, if the event doesn't
309 carry that information itself (i.e. if it was a character). */
310 Lisp_Object Vlast_event_frame
;
312 /* The timestamp of the last input event we received from the X server.
313 X Windows wants this for selection ownership. */
314 unsigned long last_event_timestamp
;
316 Lisp_Object Qself_insert_command
;
317 Lisp_Object Qforward_char
;
318 Lisp_Object Qbackward_char
;
319 Lisp_Object Qundefined
;
320 Lisp_Object Qtimer_event_handler
;
322 /* read_key_sequence stores here the command definition of the
323 key sequence that it reads. */
324 Lisp_Object read_key_sequence_cmd
;
326 /* Form to evaluate (if non-nil) when Emacs is started. */
327 Lisp_Object Vtop_level
;
329 /* User-supplied string to translate input characters through. */
330 Lisp_Object Vkeyboard_translate_table
;
332 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
333 extern Lisp_Object Vfunction_key_map
;
335 /* Another keymap that maps key sequences into key sequences.
336 This one takes precedence over ordinary definitions. */
337 extern Lisp_Object Vkey_translation_map
;
339 /* Non-nil means deactivate the mark at end of this command. */
340 Lisp_Object Vdeactivate_mark
;
342 /* Menu bar specified in Lucid Emacs fashion. */
344 Lisp_Object Vlucid_menu_bar_dirty_flag
;
345 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
347 Lisp_Object Qecho_area_clear_hook
;
349 /* Hooks to run before and after each command. */
350 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
351 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
352 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
353 /* Hook run after a command if there's no more input soon. */
354 Lisp_Object Qpost_command_idle_hook
, Vpost_command_idle_hook
;
356 /* Delay time in microseconds before running post-command-idle-hook. */
357 int post_command_idle_delay
;
359 /* List of deferred actions to be performed at a later time.
360 The precise format isn't relevant here; we just check whether it is nil. */
361 Lisp_Object Vdeferred_action_list
;
363 /* Function to call to handle deferred actions, when there are any. */
364 Lisp_Object Vdeferred_action_function
;
365 Lisp_Object Qdeferred_action_function
;
367 /* File in which we write all commands we read. */
370 /* Nonzero if input is available. */
373 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
374 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
378 extern char *pending_malloc_warning
;
380 /* Circular buffer for pre-read keyboard input. */
381 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
383 /* Vector to GCPRO the frames and windows mentioned in kbd_buffer.
385 The interrupt-level event handlers will never enqueue an event on a
386 frame which is not in Vframe_list, and once an event is dequeued,
387 internal_last_event_frame or the event itself points to the frame.
390 But while the event is sitting in the queue, it's completely
391 unprotected. Suppose the user types one command which will run for
392 a while and then delete a frame, and then types another event at
393 the frame that will be deleted, before the command gets around to
394 it. Suppose there are no references to this frame elsewhere in
395 Emacs, and a GC occurs before the second event is dequeued. Now we
396 have an event referring to a freed frame, which will crash Emacs
399 Similar things happen when an event on a scroll bar is enqueued; the
400 window may be deleted while the event is in the queue.
402 So, we use this vector to protect the frame_or_window field in the
403 event queue. That way, they'll be dequeued as dead frames or
404 windows, but still valid lisp objects.
406 If kbd_buffer[i].kind != no_event, then
407 (XVECTOR (kbd_buffer_frame_or_window)->contents[i]
408 == kbd_buffer[i].frame_or_window. */
409 static Lisp_Object kbd_buffer_frame_or_window
;
411 /* Pointer to next available character in kbd_buffer.
412 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
413 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the the
414 next available char is in kbd_buffer[0]. */
415 static struct input_event
*kbd_fetch_ptr
;
417 /* Pointer to next place to store character in kbd_buffer. This
418 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
419 character should go in kbd_buffer[0]. */
420 static volatile struct input_event
*kbd_store_ptr
;
422 /* The above pair of variables forms a "queue empty" flag. When we
423 enqueue a non-hook event, we increment kbd_store_ptr. When we
424 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
425 there is input available iff the two pointers are not equal.
427 Why not just have a flag set and cleared by the enqueuing and
428 dequeuing functions? Such a flag could be screwed up by interrupts
429 at inopportune times. */
431 /* If this flag is non-nil, we check mouse_moved to see when the
432 mouse moves, and motion events will appear in the input stream.
433 Otherwise, mouse motion is ignored. */
434 static Lisp_Object do_mouse_tracking
;
436 /* Symbols to head events. */
437 Lisp_Object Qmouse_movement
;
438 Lisp_Object Qscroll_bar_movement
;
439 Lisp_Object Qswitch_frame
;
440 Lisp_Object Qdelete_frame
;
441 Lisp_Object Qiconify_frame
;
442 Lisp_Object Qmake_frame_visible
;
444 /* Symbols to denote kinds of events. */
445 Lisp_Object Qfunction_key
;
446 Lisp_Object Qmouse_click
;
447 /* Lisp_Object Qmouse_movement; - also an event header */
449 /* Properties of event headers. */
450 Lisp_Object Qevent_kind
;
451 Lisp_Object Qevent_symbol_elements
;
453 Lisp_Object Qmenu_enable
;
455 /* An event header symbol HEAD may have a property named
456 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
457 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
458 mask of modifiers applied to it. If present, this is used to help
459 speed up parse_modifiers. */
460 Lisp_Object Qevent_symbol_element_mask
;
462 /* An unmodified event header BASE may have a property named
463 Qmodifier_cache, which is an alist mapping modifier masks onto
464 modified versions of BASE. If present, this helps speed up
466 Lisp_Object Qmodifier_cache
;
468 /* Symbols to use for parts of windows. */
469 Lisp_Object Qmode_line
;
470 Lisp_Object Qvertical_line
;
471 Lisp_Object Qvertical_scroll_bar
;
472 Lisp_Object Qmenu_bar
;
474 extern Lisp_Object Qmenu_enable
;
476 Lisp_Object
recursive_edit_unwind (), command_loop ();
477 Lisp_Object
Fthis_command_keys ();
478 Lisp_Object Qextended_command_history
;
479 EMACS_TIME
timer_check ();
481 extern char *x_get_keysym_name ();
483 static void record_menu_key ();
485 void swallow_events ();
487 Lisp_Object Qpolling_period
;
489 /* List of absolute timers. Appears in order of next scheduled event. */
490 Lisp_Object Vtimer_list
;
492 /* List of idle time timers. Appears in order of next scheduled event. */
493 Lisp_Object Vtimer_idle_list
;
495 /* Incremented whenever a timer is run. */
498 extern Lisp_Object Vprint_level
, Vprint_length
;
500 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
502 EMACS_TIME
*input_available_clear_time
;
504 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
505 Default is 1 if INTERRUPT_INPUT is defined. */
508 /* Nonzero while interrupts are temporarily deferred during redisplay. */
509 int interrupts_deferred
;
511 /* Nonzero means use ^S/^Q for flow control. */
514 /* Allow m- file to inhibit use of FIONREAD. */
515 #ifdef BROKEN_FIONREAD
519 /* We are unable to use interrupts if FIONREAD is not available,
520 so flush SIGIO so we won't try. */
527 /* If we support a window system, turn on the code to poll periodically
528 to detect C-g. It isn't actually used when doing interrupt input. */
529 #ifdef HAVE_WINDOW_SYSTEM
530 #define POLL_FOR_INPUT
533 /* Global variable declarations. */
535 /* Function for init_keyboard to call with no args (if nonzero). */
536 void (*keyboard_init_hook
) ();
538 static int read_avail_input ();
539 static void get_input_pending ();
540 static int readable_events ();
541 static Lisp_Object
read_char_x_menu_prompt ();
542 static Lisp_Object
read_char_minibuf_menu_prompt ();
543 static Lisp_Object
make_lispy_event ();
545 static Lisp_Object
make_lispy_movement ();
547 static Lisp_Object
modify_event_symbol ();
548 static Lisp_Object
make_lispy_switch_frame ();
549 static int parse_solitary_modifier ();
551 /* > 0 if we are to echo keystrokes. */
552 static int echo_keystrokes
;
554 /* Nonzero means don't try to suspend even if the operating system seems
556 static int cannot_suspend
;
558 #define min(a,b) ((a)<(b)?(a):(b))
559 #define max(a,b) ((a)>(b)?(a):(b))
561 /* Install the string STR as the beginning of the string of echoing,
562 so that it serves as a prompt for the next character.
563 Also start echoing. */
568 int len
= strlen (str
);
570 if (len
> ECHOBUFSIZE
- 4)
571 len
= ECHOBUFSIZE
- 4;
572 bcopy (str
, current_kboard
->echobuf
, len
);
573 current_kboard
->echoptr
= current_kboard
->echobuf
+ len
;
574 *current_kboard
->echoptr
= '\0';
576 current_kboard
->echo_after_prompt
= len
;
581 /* Add C to the echo string, if echoing is going on.
582 C can be a character, which is printed prettily ("M-C-x" and all that
583 jazz), or a symbol, whose name is printed. */
588 extern char *push_key_description ();
590 if (current_kboard
->immediate_echo
)
592 char *ptr
= current_kboard
->echoptr
;
594 if (ptr
!= current_kboard
->echobuf
)
597 /* If someone has passed us a composite event, use its head symbol. */
602 if (ptr
- current_kboard
->echobuf
> ECHOBUFSIZE
- 6)
605 ptr
= push_key_description (XINT (c
), ptr
);
607 else if (SYMBOLP (c
))
609 struct Lisp_String
*name
= XSYMBOL (c
)->name
;
610 if ((ptr
- current_kboard
->echobuf
) + name
->size
+ 4 > ECHOBUFSIZE
)
612 bcopy (name
->data
, ptr
, name
->size
);
616 if (current_kboard
->echoptr
== current_kboard
->echobuf
619 strcpy (ptr
, " (Type ? for further options)");
624 current_kboard
->echoptr
= ptr
;
630 /* Temporarily add a dash to the end of the echo string if it's not
631 empty, so that it serves as a mini-prompt for the very next character. */
635 if (!current_kboard
->immediate_echo
636 && current_kboard
->echoptr
== current_kboard
->echobuf
)
638 /* Do nothing if we just printed a prompt. */
639 if (current_kboard
->echo_after_prompt
640 == current_kboard
->echoptr
- current_kboard
->echobuf
)
642 /* Do nothing if not echoing at all. */
643 if (current_kboard
->echoptr
== 0)
646 /* Put a dash at the end of the buffer temporarily,
647 but make it go away when the next character is added. */
648 current_kboard
->echoptr
[0] = '-';
649 current_kboard
->echoptr
[1] = 0;
654 /* Display the current echo string, and begin echoing if not already
659 if (!current_kboard
->immediate_echo
)
662 current_kboard
->immediate_echo
= 1;
664 for (i
= 0; i
< this_command_key_count
; i
++)
667 c
= XVECTOR (this_command_keys
)->contents
[i
];
668 if (! (EVENT_HAS_PARAMETERS (c
)
669 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
676 message1_nolog (current_kboard
->echobuf
);
679 if (waiting_for_input
&& !NILP (Vquit_flag
))
680 quit_throw_to_read_char ();
683 /* Turn off echoing, for the start of a new command. */
687 current_kboard
->immediate_echo
= 0;
688 current_kboard
->echoptr
= current_kboard
->echobuf
;
689 current_kboard
->echo_after_prompt
= -1;
690 ok_to_echo_at_next_pause
= 0;
693 /* Return the length of the current echo string. */
698 return current_kboard
->echoptr
- current_kboard
->echobuf
;
701 /* Truncate the current echo message to its first LEN chars.
702 This and echo_char get used by read_key_sequence when the user
703 switches frames while entering a key sequence. */
709 current_kboard
->echobuf
[len
] = '\0';
710 current_kboard
->echoptr
= current_kboard
->echobuf
+ len
;
711 truncate_echo_area (len
);
715 /* Functions for manipulating this_command_keys. */
717 add_command_key (key
)
720 int size
= XVECTOR (this_command_keys
)->size
;
722 /* If reset-this-command-length was called recently, obey it now.
723 See the doc string of that function for an explanation of why. */
724 if (before_command_restore_flag
)
726 this_command_key_count
= before_command_key_count_1
;
727 if (this_command_key_count
< this_single_command_key_start
)
728 this_single_command_key_start
= this_command_key_count
;
729 echo_truncate (before_command_echo_length_1
);
730 before_command_restore_flag
= 0;
733 if (this_command_key_count
>= size
)
735 Lisp_Object new_keys
;
737 new_keys
= Fmake_vector (make_number (size
* 2), Qnil
);
738 bcopy (XVECTOR (this_command_keys
)->contents
,
739 XVECTOR (new_keys
)->contents
,
740 size
* sizeof (Lisp_Object
));
742 this_command_keys
= new_keys
;
745 XVECTOR (this_command_keys
)->contents
[this_command_key_count
++] = key
;
751 int count
= specpdl_ptr
- specpdl
;
754 if (command_loop_level
> 0)
756 specbind (Qstandard_output
, Qt
);
757 specbind (Qstandard_input
, Qt
);
760 val
= command_loop ();
762 Fsignal (Qquit
, Qnil
);
763 /* Handle throw from read_minibuf when using minibuffer
764 while it's active but we're in another window. */
766 Fsignal (Qerror
, Fcons (val
, Qnil
));
768 return unbind_to (count
, Qnil
);
771 /* When an auto-save happens, record the "time", and don't do again soon. */
775 last_auto_save
= num_nonmacro_input_events
;
778 /* Make an auto save happen as soon as possible at command level. */
780 force_auto_save_soon ()
782 last_auto_save
= - auto_save_interval
- 1;
784 record_asynch_buffer_change ();
787 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
788 "Invoke the editor command loop recursively.\n\
789 To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
790 that tells this function to return.\n\
791 Alternately, `(throw 'exit t)' makes this function signal an error.\n\
792 This function is called by the editor initialization to begin editing.")
795 int count
= specpdl_ptr
- specpdl
;
798 command_loop_level
++;
799 update_mode_lines
= 1;
801 record_unwind_protect (recursive_edit_unwind
,
803 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
807 return unbind_to (count
, Qnil
);
811 recursive_edit_unwind (buffer
)
815 Fset_buffer (buffer
);
817 command_loop_level
--;
818 update_mode_lines
= 1;
826 #if 0 /* Theory: if there's anything in Vunread_command_events,
827 it will right away be read by read_key_sequence,
828 and then if we do switch KBOARDS, it will go into the side
829 queue then. So we don't need to do anything special here -- rms. */
830 if (CONSP (Vunread_command_events
))
832 current_kboard
->kbd_queue
833 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
834 current_kboard
->kbd_queue_has_data
= 1;
836 Vunread_command_events
= Qnil
;
842 /* Switch to the single-kboard state, making current_kboard
843 the only KBOARD from which further input is accepted. */
846 single_kboard_state ()
853 /* Maintain a stack of kboards, so other parts of Emacs
854 can switch temporarily to the kboard of a given frame
855 and then revert to the previous status. */
860 struct kboard_stack
*next
;
863 static struct kboard_stack
*kboard_stack
;
866 push_frame_kboard (f
)
870 struct kboard_stack
*p
871 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
873 p
->next
= kboard_stack
;
874 p
->kboard
= current_kboard
;
877 current_kboard
= FRAME_KBOARD (f
);
885 struct kboard_stack
*p
= kboard_stack
;
886 current_kboard
= p
->kboard
;
887 kboard_stack
= p
->next
;
892 /* Handle errors that are not handled at inner levels
893 by printing an error message and returning to the editor command loop. */
899 Lisp_Object old_level
, old_length
;
902 if (!NILP (executing_macro
))
904 if (executing_macro_iterations
== 1)
905 sprintf (macroerror
, "After 1 kbd macro iteration: ");
907 sprintf (macroerror
, "After %d kbd macro iterations: ",
908 executing_macro_iterations
);
913 Vstandard_output
= Qt
;
914 Vstandard_input
= Qt
;
915 Vexecuting_macro
= Qnil
;
916 executing_macro
= Qnil
;
917 current_kboard
->Vprefix_arg
= Qnil
;
920 /* Avoid unquittable loop if data contains a circular list. */
921 old_level
= Vprint_level
;
922 old_length
= Vprint_length
;
923 XSETFASTINT (Vprint_level
, 10);
924 XSETFASTINT (Vprint_length
, 10);
925 cmd_error_internal (data
, macroerror
);
926 Vprint_level
= old_level
;
927 Vprint_length
= old_length
;
931 Vinhibit_quit
= Qnil
;
936 return make_number (0);
939 cmd_error_internal (data
, context
)
947 echo_area_glyphs
= 0;
949 /* If the window system or terminal frame hasn't been initialized
950 yet, or we're not interactive, it's best to dump this message out
951 to stderr and exit. */
952 if (! FRAME_MESSAGE_BUF (selected_frame
)
954 stream
= Qexternal_debugging_output
;
963 write_string_1 (context
, -1, stream
);
965 print_error_message (data
, stream
);
967 /* If the window system or terminal frame hasn't been initialized
968 yet, or we're in -batch mode, this error should cause Emacs to exit. */
969 if (! FRAME_MESSAGE_BUF (selected_frame
)
973 Fkill_emacs (make_number (-1));
977 Lisp_Object
command_loop_1 ();
978 Lisp_Object
command_loop_2 ();
979 Lisp_Object
top_level_1 ();
981 /* Entry to editor-command-loop.
982 This level has the catches for exiting/returning to editor command loop.
983 It returns nil to exit recursive edit, t to abort it. */
988 if (command_loop_level
> 0 || minibuf_level
> 0)
990 return internal_catch (Qexit
, command_loop_2
, Qnil
);
995 internal_catch (Qtop_level
, top_level_1
, Qnil
);
996 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
998 /* End of file in -batch run causes exit here. */
1004 /* Here we catch errors in execution of commands within the
1005 editing loop, and reenter the editing loop.
1006 When there is an error, cmd_error runs and returns a non-nil
1007 value to us. A value of nil means that cmd_loop_1 itself
1008 returned due to end of file (or end of kbd macro). */
1013 register Lisp_Object val
;
1016 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1017 while (!NILP (val
));
1025 return Feval (Vtop_level
);
1031 /* On entry to the outer level, run the startup file */
1032 if (!NILP (Vtop_level
))
1033 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1034 else if (!NILP (Vpurify_flag
))
1035 message ("Bare impure Emacs (standard Lisp code not loaded)");
1037 message ("Bare Emacs (standard Lisp code not loaded)");
1041 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1042 "Exit all recursive editing levels.")
1045 Fthrow (Qtop_level
, Qnil
);
1048 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1049 "Exit from the innermost recursive edit or minibuffer.")
1052 if (command_loop_level
> 0 || minibuf_level
> 0)
1053 Fthrow (Qexit
, Qnil
);
1055 error ("No recursive edit is in progress");
1058 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1059 "Abort the command that requested this recursive edit or minibuffer input.")
1062 if (command_loop_level
> 0 || minibuf_level
> 0)
1065 error ("No recursive edit is in progress");
1068 /* This is the actual command reading loop,
1069 sans error-handling encapsulation. */
1071 Lisp_Object
Fcommand_execute ();
1072 static int read_key_sequence ();
1073 void safe_run_hooks ();
1078 Lisp_Object cmd
, tem
;
1081 Lisp_Object keybuf
[30];
1086 struct buffer
*prev_buffer
;
1088 int was_locked
= single_kboard
;
1091 current_kboard
->Vprefix_arg
= Qnil
;
1092 Vdeactivate_mark
= Qnil
;
1093 waiting_for_input
= 0;
1098 this_command_key_count
= 0;
1099 this_single_command_key_start
= 0;
1101 /* Make sure this hook runs after commands that get errors and
1102 throw to top level. */
1103 /* Note that the value cell will never directly contain nil
1104 if the symbol is a local variable. */
1105 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1106 safe_run_hooks (Qpost_command_hook
);
1108 if (!NILP (Vdeferred_action_list
))
1109 call0 (Vdeferred_action_function
);
1111 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1113 if (NILP (Vunread_command_events
)
1114 && NILP (Vexecuting_macro
)
1115 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1116 safe_run_hooks (Qpost_command_idle_hook
);
1119 /* Do this after running Vpost_command_hook, for consistency. */
1120 current_kboard
->Vlast_command
= this_command
;
1124 /* Make sure the current window's buffer is selected. */
1125 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1126 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1128 /* Display any malloc warning that just came out. Use while because
1129 displaying one warning can cause another. */
1131 while (pending_malloc_warning
)
1132 display_malloc_warning ();
1136 Vdeactivate_mark
= Qnil
;
1138 /* If minibuffer on and echo area in use,
1139 wait 2 sec and redraw minibuffer. */
1141 if (minibuf_level
&& echo_area_glyphs
1142 && EQ (minibuf_window
, echo_area_window
))
1144 /* Bind inhibit-quit to t so that C-g gets read in
1145 rather than quitting back to the minibuffer. */
1146 int count
= specpdl_ptr
- specpdl
;
1147 specbind (Qinhibit_quit
, Qt
);
1149 Fsit_for (make_number (2), Qnil
, Qnil
);
1150 /* Clear the echo area. */
1152 safe_run_hooks (Qecho_area_clear_hook
);
1154 unbind_to (count
, Qnil
);
1156 /* If a C-g came in before, treat it as input now. */
1157 if (!NILP (Vquit_flag
))
1160 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1165 alloca (0); /* Cause a garbage collection now */
1166 /* Since we can free the most stuff here. */
1167 #endif /* C_ALLOCA */
1170 /* Select the frame that the last event came from. Usually,
1171 switch-frame events will take care of this, but if some lisp
1172 code swallows a switch-frame event, we'll fix things up here.
1173 Is this a good idea? */
1174 if (FRAMEP (internal_last_event_frame
)
1175 && XFRAME (internal_last_event_frame
) != selected_frame
)
1176 Fselect_frame (internal_last_event_frame
, Qnil
);
1178 /* If it has changed current-menubar from previous value,
1179 really recompute the menubar from the value. */
1180 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1181 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1182 call0 (Qrecompute_lucid_menubar
);
1184 before_command_key_count
= this_command_key_count
;
1185 before_command_echo_length
= echo_length ();
1187 this_command
= Qnil
;
1189 /* Read next key sequence; i gets its length. */
1190 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1193 /* A filter may have run while we were reading the input. */
1194 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1195 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1199 /* Now we have read a key sequence of length I,
1200 or else I is 0 and we found end of file. */
1202 if (i
== 0) /* End of file -- happens only in */
1203 return Qnil
; /* a kbd macro, at the end. */
1204 /* -1 means read_key_sequence got a menu that was rejected.
1205 Just loop around and read another command. */
1209 this_command_key_count
= 0;
1210 this_single_command_key_start
= 0;
1214 last_command_char
= keybuf
[i
- 1];
1216 /* If the previous command tried to force a specific window-start,
1217 forget about that, in case this command moves point far away
1218 from that position. But also throw away beg_unchanged and
1219 end_unchanged information in that case, so that redisplay will
1220 update the whole window properly. */
1221 if (!NILP (XWINDOW (selected_window
)->force_start
))
1223 XWINDOW (selected_window
)->force_start
= Qnil
;
1224 beg_unchanged
= end_unchanged
= 0;
1227 cmd
= read_key_sequence_cmd
;
1228 if (!NILP (Vexecuting_macro
))
1230 if (!NILP (Vquit_flag
))
1232 Vexecuting_macro
= Qt
;
1233 QUIT
; /* Make some noise. */
1234 /* Will return since macro now empty. */
1238 /* Do redisplay processing after this command except in special
1239 cases identified below that set no_redisplay to 1.
1240 (actually, there's currently no way to prevent the redisplay,
1241 and no_redisplay is ignored.
1242 Perhaps someday we will really implement it.) */
1245 prev_buffer
= current_buffer
;
1246 prev_modiff
= MODIFF
;
1247 last_point_position
= PT
;
1248 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1250 /* Execute the command. */
1253 /* Note that the value cell will never directly contain nil
1254 if the symbol is a local variable. */
1255 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1256 safe_run_hooks (Qpre_command_hook
);
1258 if (NILP (this_command
))
1260 /* nil means key is undefined. */
1262 current_kboard
->defining_kbd_macro
= Qnil
;
1263 update_mode_lines
= 1;
1264 current_kboard
->Vprefix_arg
= Qnil
;
1268 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1270 /* Recognize some common commands in common situations and
1271 do them directly. */
1272 if (EQ (this_command
, Qforward_char
) && PT
< ZV
)
1274 struct Lisp_Char_Table
*dp
1275 = window_display_table (XWINDOW (selected_window
));
1276 lose
= FETCH_BYTE (PT
);
1277 SET_PT (forward_point (1));
1279 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1280 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1281 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1282 && (lose
>= 0x20 && lose
< 0x7f)))
1283 : (lose
>= 0x20 && lose
< 0x7f))
1284 /* To extract the case of continuation on
1285 wide-column characters. */
1286 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT
)) == 1)
1287 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1289 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1291 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1293 && !windows_or_buffers_changed
1294 && EQ (current_buffer
->selective_display
, Qnil
)
1295 && !detect_input_pending ()
1296 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1297 && NILP (Vexecuting_macro
))
1298 no_redisplay
= direct_output_forward_char (1);
1301 else if (EQ (this_command
, Qbackward_char
) && PT
> BEGV
)
1303 struct Lisp_Char_Table
*dp
1304 = window_display_table (XWINDOW (selected_window
));
1305 SET_PT (forward_point (-1));
1306 lose
= FETCH_BYTE (PT
);
1308 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1309 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1310 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1311 && (lose
>= 0x20 && lose
< 0x7f)))
1312 : (lose
>= 0x20 && lose
< 0x7f))
1313 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1315 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1317 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1319 && !windows_or_buffers_changed
1320 && EQ (current_buffer
->selective_display
, Qnil
)
1321 && !detect_input_pending ()
1322 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1323 && NILP (Vexecuting_macro
))
1324 no_redisplay
= direct_output_forward_char (-1);
1327 else if (EQ (this_command
, Qself_insert_command
)
1328 /* Try this optimization only on ascii keystrokes. */
1329 && INTEGERP (last_command_char
))
1331 unsigned int c
= XINT (last_command_char
);
1334 if (NILP (Vexecuting_macro
)
1335 && !EQ (minibuf_window
, selected_window
))
1337 if (!nonundocount
|| nonundocount
>= 20)
1344 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1346 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1348 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1350 || MODIFF
<= SAVE_MODIFF
1351 || windows_or_buffers_changed
1352 || !EQ (current_buffer
->selective_display
, Qnil
)
1353 || detect_input_pending ()
1354 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1355 || !NILP (Vexecuting_macro
));
1356 value
= internal_self_insert (c
, 0);
1363 && (PT
== ZV
|| FETCH_BYTE (PT
) == '\n'))
1365 struct Lisp_Char_Table
*dp
1366 = window_display_table (XWINDOW (selected_window
));
1373 obj
= DISP_CHAR_VECTOR (dp
, lose
);
1376 /* Do it only for char codes
1377 that by default display as themselves. */
1378 if (lose
>= 0x20 && lose
<= 0x7e)
1379 no_redisplay
= direct_output_for_insert (lose
);
1381 else if (VECTORP (obj
)
1382 && XVECTOR (obj
)->size
== 1
1383 && (obj
= XVECTOR (obj
)->contents
[0],
1385 /* Insist face not specified in glyph. */
1386 && (XINT (obj
) & ((-1) << 8)) == 0)
1388 = direct_output_for_insert (XINT (obj
));
1392 if (lose
>= 0x20 && lose
<= 0x7e)
1393 no_redisplay
= direct_output_for_insert (lose
);
1400 /* Here for a command that isn't executed directly */
1403 if (NILP (current_kboard
->Vprefix_arg
))
1405 Fcommand_execute (this_command
, Qnil
, Qnil
, Qnil
);
1410 /* If there is a prefix argument,
1411 1) We don't want Vlast_command to be ``universal-argument''
1412 (that would be dumb), so don't set Vlast_command,
1413 2) we want to leave echoing on so that the prefix will be
1414 echoed as part of this key sequence, so don't call
1416 3) we want to leave this_command_key_count non-zero, so that
1417 read_char will realize that it is re-reading a character, and
1418 not echo it a second time.
1420 If the command didn't actually create a prefix arg,
1421 but is merely a frame event that is transparent to prefix args,
1422 then the above doesn't apply. */
1423 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1425 current_kboard
->Vlast_command
= this_command
;
1427 this_command_key_count
= 0;
1428 this_single_command_key_start
= 0;
1431 /* Note that the value cell will never directly contain nil
1432 if the symbol is a local variable. */
1433 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1434 safe_run_hooks (Qpost_command_hook
);
1436 if (!NILP (Vdeferred_action_list
))
1437 safe_run_hooks (Qdeferred_action_function
);
1439 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1441 if (NILP (Vunread_command_events
)
1442 && NILP (Vexecuting_macro
)
1443 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1444 safe_run_hooks (Qpost_command_idle_hook
);
1447 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1449 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1451 current_buffer
->mark_active
= Qnil
;
1452 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1454 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1455 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1459 /* Install chars successfully executed in kbd macro. */
1461 if (!NILP (current_kboard
->defining_kbd_macro
)
1462 && NILP (current_kboard
->Vprefix_arg
))
1463 finalize_kbd_macro_chars ();
1467 any_kboard_state ();
1472 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1475 safe_run_hooks_1 (hook
)
1478 return call1 (Vrun_hooks
, Vinhibit_quit
);
1481 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1484 safe_run_hooks_error (data
)
1487 Fset (Vinhibit_quit
, Qnil
);
1490 /* If we get an error while running the hook, cause the hook variable
1491 to be nil. Also inhibit quits, so that C-g won't cause the hook
1492 to mysteriously evaporate. */
1495 safe_run_hooks (hook
)
1499 int count
= specpdl_ptr
- specpdl
;
1500 specbind (Qinhibit_quit
, hook
);
1502 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
1504 unbind_to (count
, Qnil
);
1507 /* Number of seconds between polling for input. */
1510 /* Nonzero means polling for input is temporarily suppressed. */
1511 int poll_suppress_count
;
1513 /* Nonzero if polling_for_input is actually being used. */
1514 int polling_for_input
;
1516 #ifdef POLL_FOR_INPUT
1518 /* Handle an alarm once each second and read pending input
1519 so as to handle a C-g if it comces in. */
1522 input_poll_signal (signalnum
) /* If we don't have an argument, */
1523 int signalnum
; /* some compilers complain in signal calls. */
1525 /* This causes the call to start_polling at the end
1526 to do its job. It also arranges for a quit or error
1527 from within read_avail_input to resume polling. */
1528 poll_suppress_count
++;
1529 if (interrupt_input_blocked
== 0
1530 && !waiting_for_input
)
1531 read_avail_input (0);
1532 /* Turn on the SIGALRM handler and request another alarm. */
1538 /* Begin signals to poll for input, if they are appropriate.
1539 This function is called unconditionally from various places. */
1543 #ifdef POLL_FOR_INPUT
1544 if (read_socket_hook
&& !interrupt_input
)
1546 poll_suppress_count
--;
1547 if (poll_suppress_count
== 0)
1549 signal (SIGALRM
, input_poll_signal
);
1550 polling_for_input
= 1;
1551 alarm (polling_period
);
1557 /* Nonzero if we are using polling to handle input asynchronously. */
1560 input_polling_used ()
1562 #ifdef POLL_FOR_INPUT
1563 return read_socket_hook
&& !interrupt_input
;
1569 /* Turn off polling. */
1573 #ifdef POLL_FOR_INPUT
1574 if (read_socket_hook
&& !interrupt_input
)
1576 if (poll_suppress_count
== 0)
1578 polling_for_input
= 0;
1581 poll_suppress_count
++;
1586 /* Set the value of poll_suppress_count to COUNT
1587 and start or stop polling accordingly. */
1590 set_poll_suppress_count (count
)
1593 #ifdef POLL_FOR_INPUT
1594 if (count
== 0 && poll_suppress_count
!= 0)
1596 poll_suppress_count
= 1;
1599 else if (count
!= 0 && poll_suppress_count
== 0)
1603 poll_suppress_count
= count
;
1607 /* Bind polling_period to a value at least N.
1608 But don't decrease it. */
1610 bind_polling_period (n
)
1613 #ifdef POLL_FOR_INPUT
1614 int new = polling_period
;
1620 specbind (Qpolling_period
, make_number (new));
1621 /* Start a new alarm with the new period. */
1626 /* Apply the control modifier to CHARACTER. */
1632 /* Save the upper bits here. */
1633 int upper
= c
& ~0177;
1637 /* Everything in the columns containing the upper-case letters
1638 denotes a control character. */
1639 if (c
>= 0100 && c
< 0140)
1643 /* Set the shift modifier for a control char
1644 made from a shifted letter. But only for letters! */
1645 if (oc
>= 'A' && oc
<= 'Z')
1646 c
|= shift_modifier
;
1649 /* The lower-case letters denote control characters too. */
1650 else if (c
>= 'a' && c
<= 'z')
1653 /* Include the bits for control and shift
1654 only if the basic ASCII code can't indicate them. */
1658 /* Replace the high bits. */
1659 c
|= (upper
& ~ctrl_modifier
);
1666 /* Input of single characters from keyboard */
1668 Lisp_Object
print_help ();
1669 static Lisp_Object
kbd_buffer_get_event ();
1670 static void record_char ();
1673 static jmp_buf wrong_kboard_jmpbuf
;
1676 /* read a character from the keyboard; call the redisplay if needed */
1677 /* commandflag 0 means do not do auto-saving, but do do redisplay.
1678 -1 means do not do redisplay, but do do autosaving.
1681 /* The arguments MAPS and NMAPS are for menu prompting.
1682 MAPS is an array of keymaps; NMAPS is the length of MAPS.
1684 PREV_EVENT is the previous input event, or nil if we are reading
1685 the first event of a key sequence.
1687 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
1688 if we used a mouse menu to read the input, or zero otherwise. If
1689 USED_MOUSE_MENU is null, we don't dereference it.
1691 Value is t if we showed a menu and the user rejected it. */
1694 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
1698 Lisp_Object prev_event
;
1699 int *used_mouse_menu
;
1703 jmp_buf local_getcjmp
;
1705 int key_already_recorded
= 0;
1706 Lisp_Object tem
, save
;
1707 Lisp_Object also_record
;
1708 struct gcpro gcpro1
;
1712 before_command_key_count
= this_command_key_count
;
1713 before_command_echo_length
= echo_length ();
1719 if (CONSP (Vunread_command_events
))
1721 c
= XCONS (Vunread_command_events
)->car
;
1722 Vunread_command_events
= XCONS (Vunread_command_events
)->cdr
;
1724 /* Undo what read_char_x_menu_prompt did when it unread
1725 additional keys returned by Fx_popup_menu. */
1727 && (SYMBOLP (XCONS (c
)->car
) || INTEGERP (XCONS (c
)->car
))
1728 && NILP (XCONS (c
)->cdr
))
1731 if (this_command_key_count
== 0)
1737 if (unread_command_char
!= -1)
1739 XSETINT (c
, unread_command_char
);
1740 unread_command_char
= -1;
1742 if (this_command_key_count
== 0)
1748 /* If there is no function key translated before
1749 reset-this-command-lengths takes effect, forget about it. */
1750 before_command_restore_flag
= 0;
1752 if (!NILP (Vexecuting_macro
))
1754 /* We set this to Qmacro; since that's not a frame, nobody will
1755 try to switch frames on us, and the selected window will
1758 Since this event came from a macro, it would be misleading to
1759 leave internal_last_event_frame set to wherever the last
1760 real event came from. Normally, a switch-frame event selects
1761 internal_last_event_frame after each command is read, but
1762 events read from a macro should never cause a new frame to be
1764 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
1766 /* Exit the macro if we are at the end.
1767 Also, some things replace the macro with t
1768 to force an early exit. */
1769 if (EQ (Vexecuting_macro
, Qt
)
1770 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
1776 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
1777 if (STRINGP (Vexecuting_macro
)
1778 && (XINT (c
) & 0x80))
1779 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
1781 executing_macro_index
++;
1786 if (!NILP (unread_switch_frame
))
1788 c
= unread_switch_frame
;
1789 unread_switch_frame
= Qnil
;
1791 /* This event should make it into this_command_keys, and get echoed
1792 again, so we go to reread_first, rather than reread. */
1796 if (commandflag
>= 0)
1799 || detect_input_pending_run_timers (0))
1806 /* Message turns off echoing unless more keystrokes turn it on again. */
1807 if (echo_area_glyphs
&& *echo_area_glyphs
1808 && echo_area_glyphs
!= current_kboard
->echobuf
1809 && ok_to_echo_at_next_pause
!= echo_area_glyphs
)
1812 /* If already echoing, continue. */
1815 /* Try reading a character via menu prompting in the minibuf.
1816 Try this before the sit-for, because the sit-for
1817 would do the wrong thing if we are supposed to do
1818 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
1819 after a mouse event so don't try a minibuf menu. */
1821 if (nmaps
> 0 && INTERACTIVE
1822 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
1823 /* Don't bring up a menu if we already have another event. */
1824 && NILP (Vunread_command_events
)
1825 && unread_command_char
< 0
1826 && !detect_input_pending_run_timers (0))
1828 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
1831 key_already_recorded
= 1;
1836 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
1837 We will do that below, temporarily for short sections of code,
1838 when appropriate. local_getcjmp must be in effect
1839 around any call to sit_for or kbd_buffer_get_event;
1840 it *must not* be in effect when we call redisplay. */
1842 if (_setjmp (local_getcjmp
))
1844 XSETINT (c
, quit_char
);
1845 XSETFRAME (internal_last_event_frame
, selected_frame
);
1846 Vlast_event_frame
= internal_last_event_frame
;
1847 /* If we report the quit char as an event,
1848 don't do so more than once. */
1849 if (!NILP (Vinhibit_quit
))
1854 KBOARD
*kb
= FRAME_KBOARD (selected_frame
);
1855 if (kb
!= current_kboard
)
1857 Lisp_Object
*tailp
= &kb
->kbd_queue
;
1858 /* We shouldn't get here if we were in single-kboard mode! */
1861 while (CONSP (*tailp
))
1862 tailp
= &XCONS (*tailp
)->cdr
;
1865 *tailp
= Fcons (c
, Qnil
);
1866 kb
->kbd_queue_has_data
= 1;
1867 current_kboard
= kb
;
1868 longjmp (wrong_kboard_jmpbuf
, 1);
1875 timer_start_idle ();
1877 /* If in middle of key sequence and minibuffer not active,
1878 start echoing if enough time elapses. */
1880 if (minibuf_level
== 0 && !current_kboard
->immediate_echo
1881 && this_command_key_count
> 0
1883 && echo_keystrokes
> 0
1884 && (echo_area_glyphs
== 0 || *echo_area_glyphs
== 0
1885 || ok_to_echo_at_next_pause
== echo_area_glyphs
))
1889 /* After a mouse event, start echoing right away.
1890 This is because we are probably about to display a menu,
1891 and we don't want to delay before doing so. */
1892 if (EVENT_HAS_PARAMETERS (prev_event
))
1896 save_getcjmp (save_jump
);
1897 restore_getcjmp (local_getcjmp
);
1898 tem0
= sit_for (echo_keystrokes
, 0, 1, 1, 0);
1899 restore_getcjmp (save_jump
);
1901 && ! CONSP (Vunread_command_events
))
1906 /* Maybe auto save due to number of keystrokes. */
1908 if (commandflag
!= 0
1909 && auto_save_interval
> 0
1910 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
1911 && !detect_input_pending_run_timers (0))
1913 Fdo_auto_save (Qnil
, Qnil
);
1914 /* Hooks can actually change some buffers in auto save. */
1918 /* Try reading using an X menu.
1919 This is never confused with reading using the minibuf
1920 because the recursive call of read_char in read_char_minibuf_menu_prompt
1921 does not pass on any keymaps. */
1923 if (nmaps
> 0 && INTERACTIVE
1924 && !NILP (prev_event
)
1925 && EVENT_HAS_PARAMETERS (prev_event
)
1926 && !EQ (XCONS (prev_event
)->car
, Qmenu_bar
)
1927 /* Don't bring up a menu if we already have another event. */
1928 && NILP (Vunread_command_events
)
1929 && unread_command_char
< 0)
1931 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
1933 /* Now that we have read an event, Emacs is not idle. */
1939 /* Maybe autosave and/or garbage collect due to idleness. */
1941 if (INTERACTIVE
&& NILP (c
))
1943 int delay_level
, buffer_size
;
1945 /* Slow down auto saves logarithmically in size of current buffer,
1946 and garbage collect while we're at it. */
1947 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
1948 last_non_minibuf_size
= Z
- BEG
;
1949 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
1951 while (buffer_size
> 64)
1952 delay_level
++, buffer_size
-= buffer_size
>> 2;
1953 if (delay_level
< 4) delay_level
= 4;
1954 /* delay_level is 4 for files under around 50k, 7 at 100k,
1955 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
1957 /* Auto save if enough time goes by without input. */
1958 if (commandflag
!= 0
1959 && num_nonmacro_input_events
> last_auto_save
1960 && INTEGERP (Vauto_save_timeout
)
1961 && XINT (Vauto_save_timeout
) > 0)
1965 save_getcjmp (save_jump
);
1966 restore_getcjmp (local_getcjmp
);
1967 tem0
= sit_for (delay_level
* XFASTINT (Vauto_save_timeout
) / 4,
1969 restore_getcjmp (save_jump
);
1972 && ! CONSP (Vunread_command_events
))
1974 Fdo_auto_save (Qnil
, Qnil
);
1976 /* If we have auto-saved and there is still no input
1977 available, garbage collect if there has been enough
1978 consing going on to make it worthwhile. */
1979 if (!detect_input_pending_run_timers (0)
1980 && consing_since_gc
> gc_cons_threshold
/ 2)
1981 Fgarbage_collect ();
1988 /* If this has become non-nil here, it has been set by a timer
1989 or sentinel or filter. */
1990 if (CONSP (Vunread_command_events
))
1992 c
= XCONS (Vunread_command_events
)->car
;
1993 Vunread_command_events
= XCONS (Vunread_command_events
)->cdr
;
1996 /* Read something from current KBOARD's side queue, if possible. */
2000 if (current_kboard
->kbd_queue_has_data
)
2002 if (!CONSP (current_kboard
->kbd_queue
))
2004 c
= XCONS (current_kboard
->kbd_queue
)->car
;
2005 current_kboard
->kbd_queue
2006 = XCONS (current_kboard
->kbd_queue
)->cdr
;
2007 if (NILP (current_kboard
->kbd_queue
))
2008 current_kboard
->kbd_queue_has_data
= 0;
2009 input_pending
= readable_events (0);
2010 if (EVENT_HAS_PARAMETERS (c
)
2011 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2012 internal_last_event_frame
= XCONS (XCONS (c
)->cdr
)->car
;
2013 Vlast_event_frame
= internal_last_event_frame
;
2018 /* If current_kboard's side queue is empty check the other kboards.
2019 If one of them has data that we have not yet seen here,
2020 switch to it and process the data waiting for it.
2022 Note: if the events queued up for another kboard
2023 have already been seen here, and therefore are not a complete command,
2024 the kbd_queue_has_data field is 0, so we skip that kboard here.
2025 That's to avoid an infinite loop switching between kboards here. */
2026 if (NILP (c
) && !single_kboard
)
2029 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2030 if (kb
->kbd_queue_has_data
)
2032 current_kboard
= kb
;
2033 longjmp (wrong_kboard_jmpbuf
, 1);
2042 /* Finally, we read from the main queue,
2043 and if that gives us something we can't use yet, we put it on the
2044 appropriate side queue and try again. */
2050 /* Actually read a character, waiting if necessary. */
2051 save_getcjmp (save_jump
);
2052 restore_getcjmp (local_getcjmp
);
2053 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
);
2054 restore_getcjmp (save_jump
);
2057 if (! NILP (c
) && (kb
!= current_kboard
))
2059 Lisp_Object
*tailp
= &kb
->kbd_queue
;
2060 while (CONSP (*tailp
))
2061 tailp
= &XCONS (*tailp
)->cdr
;
2064 *tailp
= Fcons (c
, Qnil
);
2065 kb
->kbd_queue_has_data
= 1;
2069 current_kboard
= kb
;
2070 longjmp (wrong_kboard_jmpbuf
, 1);
2075 /* Terminate Emacs in batch mode if at eof. */
2076 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2077 Fkill_emacs (make_number (1));
2081 /* Add in any extra modifiers, where appropriate. */
2082 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2083 || ((extra_keyboard_modifiers
& 0177) < ' '
2084 && (extra_keyboard_modifiers
& 0177) != 0))
2085 XSETINT (c
, make_ctrl_char (XINT (c
)));
2087 /* Transfer any other modifier bits directly from
2088 extra_keyboard_modifiers to c. Ignore the actual character code
2089 in the low 16 bits of extra_keyboard_modifiers. */
2090 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2101 if (commandflag
>= 0
2102 && !input_pending
&& !detect_input_pending_run_timers (0))
2110 /* Buffer switch events are only for internal wakeups
2111 so don't show them to the user.
2112 Also, don't record a key if we already did. */
2113 if (BUFFERP (c
) || key_already_recorded
)
2116 /* Process special events within read_char
2117 and loop around to read another event. */
2120 tem
= get_keyelt (access_keymap (get_keymap_1 (Vspecial_event_map
, 0, 0),
2126 int was_locked
= single_kboard
;
2128 last_input_char
= c
;
2129 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
2131 /* Resume allowing input from any kboard, if that was true before. */
2133 any_kboard_state ();
2138 /* Wipe the echo area. */
2139 if (echo_area_glyphs
)
2140 safe_run_hooks (Qecho_area_clear_hook
);
2141 echo_area_glyphs
= 0;
2143 /* Handle things that only apply to characters. */
2146 /* If kbd_buffer_get_event gave us an EOF, return that. */
2150 if (STRINGP (Vkeyboard_translate_table
)
2151 && XSTRING (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2152 XSETINT (c
, XSTRING (Vkeyboard_translate_table
)->data
[XFASTINT (c
)]);
2153 else if ((VECTORP (Vkeyboard_translate_table
)
2154 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2155 || (CHAR_TABLE_P (Vkeyboard_translate_table
)
2156 && CHAR_TABLE_ORDINARY_SLOTS
> (unsigned) XFASTINT (c
)))
2159 d
= Faref (Vkeyboard_translate_table
, c
);
2160 /* nil in keyboard-translate-table means no translation. */
2166 /* If this event is a mouse click in the menu bar,
2167 return just menu-bar for now. Modify the mouse click event
2168 so we won't do this twice, then queue it up. */
2169 if (EVENT_HAS_PARAMETERS (c
)
2170 && CONSP (XCONS (c
)->cdr
)
2171 && CONSP (EVENT_START (c
))
2172 && CONSP (XCONS (EVENT_START (c
))->cdr
))
2176 posn
= POSN_BUFFER_POSN (EVENT_START (c
));
2177 /* Handle menu-bar events:
2178 insert the dummy prefix event `menu-bar'. */
2179 if (EQ (posn
, Qmenu_bar
))
2181 /* Change menu-bar to (menu-bar) as the event "position". */
2182 POSN_BUFFER_POSN (EVENT_START (c
)) = Fcons (posn
, Qnil
);
2185 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2191 if (! NILP (also_record
))
2192 record_char (also_record
);
2199 before_command_key_count
= this_command_key_count
;
2200 before_command_echo_length
= echo_length ();
2202 /* Don't echo mouse motion events. */
2204 && ! (EVENT_HAS_PARAMETERS (c
)
2205 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
2208 if (! NILP (also_record
))
2209 echo_char (also_record
);
2210 /* Once we reread a character, echoing can happen
2211 the next time we pause to read a new one. */
2212 ok_to_echo_at_next_pause
= echo_area_glyphs
;
2215 /* Record this character as part of the current key. */
2216 add_command_key (c
);
2217 if (! NILP (also_record
))
2218 add_command_key (also_record
);
2220 /* Re-reading in the middle of a command */
2222 last_input_char
= c
;
2225 /* Process the help character specially if enabled */
2226 if (!NILP (Vhelp_form
) && help_char_p (c
))
2229 count
= specpdl_ptr
- specpdl
;
2231 record_unwind_protect (Fset_window_configuration
,
2232 Fcurrent_window_configuration (Qnil
));
2234 tem0
= Feval (Vhelp_form
);
2236 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
2240 c
= read_char (0, 0, 0, Qnil
, 0);
2241 while (BUFFERP (c
));
2242 /* Remove the help from the frame */
2243 unbind_to (count
, Qnil
);
2246 if (EQ (c
, make_number (040)))
2250 c
= read_char (0, 0, 0, Qnil
, 0);
2251 while (BUFFERP (c
));
2258 /* Record a key that came from a mouse menu.
2259 Record it for echoing, for this-command-keys, and so on. */
2265 /* Wipe the echo area. */
2266 echo_area_glyphs
= 0;
2270 before_command_key_count
= this_command_key_count
;
2271 before_command_echo_length
= echo_length ();
2273 /* Don't echo mouse motion events. */
2274 if (echo_keystrokes
)
2278 /* Once we reread a character, echoing can happen
2279 the next time we pause to read a new one. */
2280 ok_to_echo_at_next_pause
= 0;
2283 /* Record this character as part of the current key. */
2284 add_command_key (c
);
2286 /* Re-reading in the middle of a command */
2287 last_input_char
= c
;
2291 /* Return 1 if should recognize C as "the help character". */
2299 if (EQ (c
, Vhelp_char
))
2301 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
2302 if (EQ (c
, XCONS (tail
)->car
))
2307 /* Record the input event C in various ways. */
2314 XVECTOR (recent_keys
)->contents
[recent_keys_index
] = c
;
2315 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
2316 recent_keys_index
= 0;
2318 /* Write c to the dribble file. If c is a lispy event, write
2319 the event's symbol to the dribble file, in <brackets>. Bleaugh.
2320 If you, dear reader, have a better idea, you've got the source. :-) */
2325 if (XUINT (c
) < 0x100)
2326 putc (XINT (c
), dribble
);
2328 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
2332 Lisp_Object dribblee
;
2334 /* If it's a structured event, take the event header. */
2335 dribblee
= EVENT_HEAD (c
);
2337 if (SYMBOLP (dribblee
))
2339 putc ('<', dribble
);
2340 fwrite (XSYMBOL (dribblee
)->name
->data
, sizeof (char),
2341 XSYMBOL (dribblee
)->name
->size
,
2343 putc ('>', dribble
);
2350 store_kbd_macro_char (c
);
2352 num_nonmacro_input_events
++;
2359 struct buffer
*old
= current_buffer
;
2360 Fprinc (object
, Qnil
);
2361 set_buffer_internal (XBUFFER (Vstandard_output
));
2362 call0 (intern ("help-mode"));
2363 set_buffer_internal (old
);
2367 /* Copy out or in the info on where C-g should throw to.
2368 This is used when running Lisp code from within get_char,
2369 in case get_char is called recursively.
2370 See read_process_output. */
2375 bcopy (getcjmp
, temp
, sizeof getcjmp
);
2378 restore_getcjmp (temp
)
2381 bcopy (temp
, getcjmp
, sizeof getcjmp
);
2386 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
2387 of this function. */
2390 tracking_off (old_value
)
2391 Lisp_Object old_value
;
2393 do_mouse_tracking
= old_value
;
2394 if (NILP (old_value
))
2396 /* Redisplay may have been preempted because there was input
2397 available, and it assumes it will be called again after the
2398 input has been processed. If the only input available was
2399 the sort that we have just disabled, then we need to call
2401 if (!readable_events (1))
2403 redisplay_preserve_echo_area ();
2404 get_input_pending (&input_pending
, 1);
2409 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
2410 "Evaluate BODY with mouse movement events enabled.\n\
2411 Within a `track-mouse' form, mouse motion generates input events that\n\
2412 you can read with `read-event'.\n\
2413 Normally, mouse motion is ignored.")
2417 int count
= specpdl_ptr
- specpdl
;
2420 record_unwind_protect (tracking_off
, do_mouse_tracking
);
2422 do_mouse_tracking
= Qt
;
2424 val
= Fprogn (args
);
2425 return unbind_to (count
, val
);
2428 /* If mouse has moved on some frame, return one of those frames.
2429 Return 0 otherwise. */
2434 Lisp_Object tail
, frame
;
2436 FOR_EACH_FRAME (tail
, frame
)
2438 if (XFRAME (frame
)->mouse_moved
)
2439 return XFRAME (frame
);
2445 #endif /* HAVE_MOUSE */
2447 /* Low level keyboard/mouse input.
2448 kbd_buffer_store_event places events in kbd_buffer, and
2449 kbd_buffer_get_event retrieves them. */
2451 /* Return true iff there are any events in the queue that read-char
2452 would return. If this returns false, a read-char would block. */
2454 readable_events (do_timers_now
)
2458 timer_check (do_timers_now
);
2460 if (kbd_fetch_ptr
!= kbd_store_ptr
)
2463 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
2468 if (current_kboard
->kbd_queue_has_data
)
2474 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2475 if (kb
->kbd_queue_has_data
)
2481 /* Set this for debugging, to have a way to get out */
2486 event_to_kboard (event
)
2487 struct input_event
*event
;
2490 frame
= event
->frame_or_window
;
2492 frame
= XCONS (frame
)->car
;
2493 else if (WINDOWP (frame
))
2494 frame
= WINDOW_FRAME (XWINDOW (frame
));
2496 /* There are still some events that don't set this field.
2497 For now, just ignore the problem.
2498 Also ignore dead frames here. */
2499 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
2502 return FRAME_KBOARD (XFRAME (frame
));
2506 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
2509 kbd_buffer_store_event (event
)
2510 register struct input_event
*event
;
2512 if (event
->kind
== no_event
)
2515 if (event
->kind
== ascii_keystroke
)
2517 register int c
= event
->code
& 0377;
2519 if (event
->modifiers
& ctrl_modifier
)
2520 c
= make_ctrl_char (c
);
2522 c
|= (event
->modifiers
2523 & (meta_modifier
| alt_modifier
2524 | hyper_modifier
| super_modifier
));
2528 extern SIGTYPE
interrupt_signal ();
2531 struct input_event
*sp
;
2534 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
2535 kb
!= current_kboard
))
2538 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
2539 Fcons (make_number (c
), Qnil
));
2540 kb
->kbd_queue_has_data
= 1;
2541 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
2543 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
2546 if (event_to_kboard (sp
) == kb
)
2548 sp
->kind
= no_event
;
2549 sp
->frame_or_window
= Qnil
;
2556 /* If this results in a quit_char being returned to Emacs as
2557 input, set Vlast_event_frame properly. If this doesn't
2558 get returned to Emacs as an event, the next event read
2559 will set Vlast_event_frame again, so this is safe to do. */
2563 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
2565 focus
= event
->frame_or_window
;
2566 internal_last_event_frame
= focus
;
2567 Vlast_event_frame
= focus
;
2570 last_event_timestamp
= event
->timestamp
;
2571 interrupt_signal ();
2575 if (c
&& c
== stop_character
)
2581 /* Don't insert two buffer_switch_event's in a row.
2582 Just ignore the second one. */
2583 else if (event
->kind
== buffer_switch_event
2584 && kbd_fetch_ptr
!= kbd_store_ptr
2585 && kbd_store_ptr
->kind
== buffer_switch_event
)
2588 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
2589 kbd_store_ptr
= kbd_buffer
;
2591 /* Don't let the very last slot in the buffer become full,
2592 since that would make the two pointers equal,
2593 and that is indistinguishable from an empty buffer.
2594 Discard the event if it would fill the last slot. */
2595 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
2597 volatile struct input_event
*sp
= kbd_store_ptr
;
2598 sp
->kind
= event
->kind
;
2599 if (event
->kind
== selection_request_event
)
2601 /* We must not use the ordinary copying code for this case,
2602 since `part' is an enum and copying it might not copy enough
2604 bcopy (event
, (char *) sp
, sizeof (*event
));
2608 sp
->code
= event
->code
;
2609 sp
->part
= event
->part
;
2610 sp
->frame_or_window
= event
->frame_or_window
;
2611 sp
->modifiers
= event
->modifiers
;
2614 sp
->timestamp
= event
->timestamp
;
2616 (XVECTOR (kbd_buffer_frame_or_window
)->contents
[kbd_store_ptr
2618 = event
->frame_or_window
);
2624 /* Read one event from the event buffer, waiting if necessary.
2625 The value is a Lisp object representing the event.
2626 The value is nil for an event that should be ignored,
2627 or that was handled here.
2628 We always read and discard one event. */
2631 kbd_buffer_get_event (kbp
, used_mouse_menu
)
2633 int *used_mouse_menu
;
2637 EMACS_TIME next_timer_delay
;
2643 *kbp
= current_kboard
;
2647 /* Wait until there is input available. */
2650 if (kbd_fetch_ptr
!= kbd_store_ptr
)
2653 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
2657 /* If the quit flag is set, then read_char will return
2658 quit_char, so that counts as "available input." */
2659 if (!NILP (Vquit_flag
))
2660 quit_throw_to_read_char ();
2662 /* One way or another, wait until input is available; then, if
2663 interrupt handlers have not read it, read it now. */
2666 wait_for_kbd_input ();
2668 /* Note SIGIO has been undef'd if FIONREAD is missing. */
2672 if (kbd_fetch_ptr
!= kbd_store_ptr
)
2675 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
2679 Lisp_Object minus_one
;
2681 XSETINT (minus_one
, -1);
2682 wait_reading_process_input (0, 0, minus_one
, 1);
2684 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
2685 /* Pass 1 for EXPECT since we just waited to have input. */
2686 read_avail_input (1);
2688 #endif /* not VMS */
2691 if (CONSP (Vunread_command_events
))
2694 first
= XCONS (Vunread_command_events
)->car
;
2695 Vunread_command_events
= XCONS (Vunread_command_events
)->cdr
;
2696 *kbp
= current_kboard
;
2700 /* At this point, we know that there is a readable event available
2701 somewhere. If the event queue is empty, then there must be a
2702 mouse movement enabled and available. */
2703 if (kbd_fetch_ptr
!= kbd_store_ptr
)
2705 struct input_event
*event
;
2707 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
2711 last_event_timestamp
= event
->timestamp
;
2714 *kbp
= event_to_kboard (event
);
2716 *kbp
= current_kboard
; /* Better than returning null ptr? */
2718 *kbp
= &the_only_kboard
;
2723 /* These two kinds of events get special handling
2724 and don't actually appear to the command loop.
2725 We return nil for them. */
2726 if (event
->kind
== selection_request_event
)
2729 struct input_event copy
;
2731 /* Remove it from the buffer before processing it,
2732 since otherwise swallow_events will see it
2733 and process it again. */
2735 kbd_fetch_ptr
= event
+ 1;
2736 input_pending
= readable_events (0);
2737 x_handle_selection_request (©
);
2739 /* We're getting selection request events, but we don't have
2745 else if (event
->kind
== selection_clear_event
)
2748 struct input_event copy
;
2750 /* Remove it from the buffer before processing it. */
2752 kbd_fetch_ptr
= event
+ 1;
2753 input_pending
= readable_events (0);
2754 x_handle_selection_clear (©
);
2756 /* We're getting selection request events, but we don't have
2761 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
2762 else if (event
->kind
== delete_window_event
)
2764 /* Make an event (delete-frame (FRAME)). */
2765 obj
= Fcons (event
->frame_or_window
, Qnil
);
2766 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
2767 kbd_fetch_ptr
= event
+ 1;
2769 else if (event
->kind
== iconify_event
)
2771 /* Make an event (iconify-frame (FRAME)). */
2772 obj
= Fcons (event
->frame_or_window
, Qnil
);
2773 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
2774 kbd_fetch_ptr
= event
+ 1;
2776 else if (event
->kind
== deiconify_event
)
2778 /* Make an event (make-frame-visible (FRAME)). */
2779 obj
= Fcons (event
->frame_or_window
, Qnil
);
2780 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
2781 kbd_fetch_ptr
= event
+ 1;
2784 else if (event
->kind
== buffer_switch_event
)
2786 /* The value doesn't matter here; only the type is tested. */
2787 XSETBUFFER (obj
, current_buffer
);
2788 kbd_fetch_ptr
= event
+ 1;
2790 #ifdef USE_X_TOOLKIT
2791 else if (event
->kind
== menu_bar_activate_event
)
2793 kbd_fetch_ptr
= event
+ 1;
2794 input_pending
= readable_events (0);
2795 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
2796 x_activate_menubar (XFRAME (event
->frame_or_window
));
2799 /* Just discard these, by returning nil.
2800 With MULTI_KBOARD, these events are used as placeholders
2801 when we need to randomly delete events from the queue.
2802 (They shouldn't otherwise be found in the buffer,
2803 but on some machines it appears they do show up
2804 even without MULTI_KBOARD.) */
2805 else if (event
->kind
== no_event
)
2806 kbd_fetch_ptr
= event
+ 1;
2808 /* If this event is on a different frame, return a switch-frame this
2809 time, and leave the event in the queue for next time. */
2815 frame
= event
->frame_or_window
;
2817 frame
= XCONS (frame
)->car
;
2818 else if (WINDOWP (frame
))
2819 frame
= WINDOW_FRAME (XWINDOW (frame
));
2821 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
2825 if (! EQ (frame
, internal_last_event_frame
)
2826 && XFRAME (frame
) != selected_frame
)
2827 obj
= make_lispy_switch_frame (frame
);
2828 internal_last_event_frame
= frame
;
2830 /* If we didn't decide to make a switch-frame event, go ahead
2831 and build a real event from the queue entry. */
2835 obj
= make_lispy_event (event
);
2836 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
2837 /* If this was a menu selection, then set the flag to inhibit
2838 writing to last_nonmenu_event. Don't do this if the event
2839 we're returning is (menu-bar), though; that indicates the
2840 beginning of the menu sequence, and we might as well leave
2841 that as the `event with parameters' for this selection. */
2842 if (event
->kind
== menu_bar_event
2843 && !(CONSP (obj
) && EQ (XCONS (obj
)->car
, Qmenu_bar
))
2845 *used_mouse_menu
= 1;
2848 /* Wipe out this event, to catch bugs. */
2849 event
->kind
= no_event
;
2850 XVECTOR (kbd_buffer_frame_or_window
)->contents
[event
- kbd_buffer
] = Qnil
;
2852 kbd_fetch_ptr
= event
+ 1;
2857 /* Try generating a mouse motion event. */
2858 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
2860 FRAME_PTR f
= some_mouse_moved ();
2861 Lisp_Object bar_window
;
2862 enum scroll_bar_part part
;
2866 *kbp
= current_kboard
;
2867 /* Note that this uses F to determine which display to look at.
2868 If there is no valid info, it does not store anything
2869 so x remains nil. */
2871 (*mouse_position_hook
) (&f
, 0, &bar_window
, &part
, &x
, &y
, &time
);
2875 /* Decide if we should generate a switch-frame event. Don't
2876 generate switch-frame events for motion outside of all Emacs
2882 frame
= FRAME_FOCUS_FRAME (f
);
2884 XSETFRAME (frame
, f
);
2886 if (! EQ (frame
, internal_last_event_frame
)
2887 && XFRAME (frame
) != selected_frame
)
2888 obj
= make_lispy_switch_frame (frame
);
2889 internal_last_event_frame
= frame
;
2892 /* If we didn't decide to make a switch-frame event, go ahead and
2893 return a mouse-motion event. */
2894 if (!NILP (x
) && NILP (obj
))
2895 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
2897 #endif /* HAVE_MOUSE */
2899 /* We were promised by the above while loop that there was
2900 something for us to read! */
2903 input_pending
= readable_events (0);
2905 Vlast_event_frame
= internal_last_event_frame
;
2910 /* Process any events that are not user-visible,
2911 then return, without reading any user-visible events. */
2914 swallow_events (do_display
)
2919 while (kbd_fetch_ptr
!= kbd_store_ptr
)
2921 struct input_event
*event
;
2923 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
2927 last_event_timestamp
= event
->timestamp
;
2929 /* These two kinds of events get special handling
2930 and don't actually appear to the command loop. */
2931 if (event
->kind
== selection_request_event
)
2934 struct input_event copy
;
2936 /* Remove it from the buffer before processing it,
2937 since otherwise swallow_events called recursively could see it
2938 and process it again. */
2940 kbd_fetch_ptr
= event
+ 1;
2941 input_pending
= readable_events (0);
2942 x_handle_selection_request (©
);
2944 /* We're getting selection request events, but we don't have
2950 else if (event
->kind
== selection_clear_event
)
2953 struct input_event copy
;
2955 /* Remove it from the buffer before processing it, */
2958 kbd_fetch_ptr
= event
+ 1;
2959 input_pending
= readable_events (0);
2960 x_handle_selection_clear (©
);
2962 /* We're getting selection request events, but we don't have
2971 old_timers_run
= timers_run
;
2972 get_input_pending (&input_pending
, 1);
2974 if (timers_run
!= old_timers_run
&& do_display
)
2975 redisplay_preserve_echo_area ();
2978 static EMACS_TIME timer_idleness_start_time
;
2980 /* Record the start of when Emacs is idle,
2981 for the sake of running idle-time timers. */
2987 /* If we are already in the idle state, do nothing. */
2988 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
2991 EMACS_GET_TIME (timer_idleness_start_time
);
2993 /* Mark all idle-time timers as once again candidates for running. */
2994 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCONS (timers
)->cdr
)
2998 timer
= XCONS (timers
)->car
;
3000 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
3002 XVECTOR (timer
)->contents
[0] = Qnil
;
3006 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
3010 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
3013 /* This is only for debugging. */
3014 struct input_event last_timer_event
;
3016 /* Check whether a timer has fired. To prevent larger problems we simply
3017 disregard elements that are not proper timers. Do not make a circular
3018 timer list for the time being.
3020 Returns the number of seconds to wait until the next timer fires. If a
3021 timer is triggering now, return zero seconds.
3022 If no timer is active, return -1 seconds.
3024 If a timer is ripe, we run it, with quitting turned off.
3026 DO_IT_NOW is now ignored. It used to mean that we should
3027 run the timer directly instead of queueing a timer-event.
3028 Now we always run timers directly. */
3031 timer_check (do_it_now
)
3034 EMACS_TIME nexttime
;
3035 EMACS_TIME now
, idleness_now
;
3036 Lisp_Object timers
, idle_timers
, chosen_timer
;
3037 struct gcpro gcpro1
, gcpro2
, gcpro3
;
3039 EMACS_SET_SECS (nexttime
, -1);
3040 EMACS_SET_USECS (nexttime
, -1);
3042 /* Always consider the ordinary timers. */
3043 timers
= Vtimer_list
;
3044 /* Consider the idle timers only if Emacs is idle. */
3045 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
3046 idle_timers
= Vtimer_idle_list
;
3049 chosen_timer
= Qnil
;
3050 GCPRO3 (timers
, idle_timers
, chosen_timer
);
3052 if (CONSP (timers
) || CONSP (idle_timers
))
3054 EMACS_GET_TIME (now
);
3055 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
3056 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
3059 while (CONSP (timers
) || CONSP (idle_timers
))
3061 int triggertime
= EMACS_SECS (now
);
3062 Lisp_Object
*vector
;
3063 Lisp_Object timer
, idle_timer
;
3064 EMACS_TIME timer_time
, idle_timer_time
;
3065 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
3067 /* Skip past invalid timers and timers already handled. */
3070 timer
= XCONS (timers
)->car
;
3071 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
3073 timers
= XCONS (timers
)->cdr
;
3076 vector
= XVECTOR (timer
)->contents
;
3078 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
3079 || !INTEGERP (vector
[3])
3080 || ! NILP (vector
[0]))
3082 timers
= XCONS (timers
)->cdr
;
3086 if (!NILP (idle_timers
))
3088 timer
= XCONS (idle_timers
)->car
;
3089 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
3091 idle_timers
= XCONS (idle_timers
)->cdr
;
3094 vector
= XVECTOR (timer
)->contents
;
3096 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
3097 || !INTEGERP (vector
[3])
3098 || ! NILP (vector
[0]))
3100 idle_timers
= XCONS (idle_timers
)->cdr
;
3105 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
3106 based on the next ordinary timer.
3107 TIMER_DIFFERENCE is the distance in time from NOW to when
3108 this timer becomes ripe (negative if it's already ripe). */
3111 timer
= XCONS (timers
)->car
;
3112 vector
= XVECTOR (timer
)->contents
;
3113 EMACS_SET_SECS (timer_time
,
3114 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
3115 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
3116 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
3119 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
3120 based on the next idle timer. */
3121 if (!NILP (idle_timers
))
3123 idle_timer
= XCONS (idle_timers
)->car
;
3124 vector
= XVECTOR (idle_timer
)->contents
;
3125 EMACS_SET_SECS (idle_timer_time
,
3126 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
3127 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
3128 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
3131 /* Decide which timer is the next timer,
3132 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
3133 Also step down the list where we found that timer. */
3135 if (! NILP (timers
) && ! NILP (idle_timers
))
3138 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
3139 if (EMACS_TIME_NEG_P (temp
))
3141 chosen_timer
= timer
;
3142 timers
= XCONS (timers
)->cdr
;
3143 difference
= timer_difference
;
3147 chosen_timer
= idle_timer
;
3148 idle_timers
= XCONS (idle_timers
)->cdr
;
3149 difference
= idle_timer_difference
;
3152 else if (! NILP (timers
))
3154 chosen_timer
= timer
;
3155 timers
= XCONS (timers
)->cdr
;
3156 difference
= timer_difference
;
3160 chosen_timer
= idle_timer
;
3161 idle_timers
= XCONS (idle_timers
)->cdr
;
3162 difference
= idle_timer_difference
;
3164 vector
= XVECTOR (chosen_timer
)->contents
;
3166 /* If timer is rupe, run it if it hasn't been run. */
3167 if (EMACS_TIME_NEG_P (difference
)
3168 || (EMACS_SECS (difference
) == 0
3169 && EMACS_USECS (difference
) == 0))
3171 if (NILP (vector
[0]))
3174 int was_locked
= single_kboard
;
3175 int count
= specpdl_ptr
- specpdl
;
3177 /* Mark the timer as triggered to prevent problems if the lisp
3178 code fails to reschedule it right. */
3181 specbind (Qinhibit_quit
, Qt
);
3183 call1 (Qtimer_event_handler
, chosen_timer
);
3186 unbind_to (count
, Qnil
);
3188 /* Resume allowing input from any kboard, if that was true before. */
3190 any_kboard_state ();
3192 /* Since we have handled the event,
3193 we don't need to tell the caller to wake up and do it. */
3197 /* When we encounter a timer that is still waiting,
3198 return the amount of time to wait before it is ripe. */
3205 /* No timers are pending in the future. */
3206 /* Return 0 if we generated an event, and -1 if not. */
3211 /* Caches for modify_event_symbol. */
3212 static Lisp_Object accent_key_syms
;
3213 static Lisp_Object func_key_syms
;
3214 static Lisp_Object mouse_syms
;
3216 /* This is a list of keysym codes for special "accent" characters.
3217 It parallels lispy_accent_keys. */
3219 static int lispy_accent_codes
[] =
3221 #ifdef XK_dead_circumflex
3226 #ifdef XK_dead_grave
3231 #ifdef XK_dead_tilde
3236 #ifdef XK_dead_diaeresis
3241 #ifdef XK_dead_macron
3246 #ifdef XK_dead_degree
3251 #ifdef XK_dead_acute
3256 #ifdef XK_dead_cedilla
3261 #ifdef XK_dead_breve
3266 #ifdef XK_dead_ogonek
3271 #ifdef XK_dead_caron
3276 #ifdef XK_dead_doubleacute
3277 XK_dead_doubleacute
,
3281 #ifdef XK_dead_abovedot
3288 /* This is a list of Lisp names for special "accent" characters.
3289 It parallels lispy_accent_codes. */
3291 static char *lispy_accent_keys
[] =
3309 #define FUNCTION_KEY_OFFSET 0x0
3311 char *lispy_function_keys
[] =
3315 0, /* VK_LBUTTON 0x01 */
3316 0, /* VK_RBUTTON 0x02 */
3317 "cancel", /* VK_CANCEL 0x03 */
3318 0, /* VK_MBUTTON 0x04 */
3320 0, 0, 0, /* 0x05 .. 0x07 */
3322 "backspace", /* VK_BACK 0x08 */
3323 "tab", /* VK_TAB 0x09 */
3325 0, 0, /* 0x0A .. 0x0B */
3327 "clear", /* VK_CLEAR 0x0C */
3328 "return", /* VK_RETURN 0x0D */
3330 0, 0, /* 0x0E .. 0x0F */
3332 "shift", /* VK_SHIFT 0x10 */
3333 "control", /* VK_CONTROL 0x11 */
3334 "menu", /* VK_MENU 0x12 */
3335 "pause", /* VK_PAUSE 0x13 */
3336 "capital", /* VK_CAPITAL 0x14 */
3338 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
3340 0, /* VK_ESCAPE 0x1B */
3342 0, 0, 0, 0, /* 0x1C .. 0x1F */
3344 0, /* VK_SPACE 0x20 */
3345 "prior", /* VK_PRIOR 0x21 */
3346 "next", /* VK_NEXT 0x22 */
3347 "end", /* VK_END 0x23 */
3348 "home", /* VK_HOME 0x24 */
3349 "left", /* VK_LEFT 0x25 */
3350 "up", /* VK_UP 0x26 */
3351 "right", /* VK_RIGHT 0x27 */
3352 "down", /* VK_DOWN 0x28 */
3353 "select", /* VK_SELECT 0x29 */
3354 "print", /* VK_PRINT 0x2A */
3355 "execute", /* VK_EXECUTE 0x2B */
3356 "snapshot", /* VK_SNAPSHOT 0x2C */
3357 "insert", /* VK_INSERT 0x2D */
3358 "delete", /* VK_DELETE 0x2E */
3359 "help", /* VK_HELP 0x2F */
3361 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
3363 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3365 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
3367 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
3369 0, 0, 0, 0, 0, 0, 0, 0, 0,
3370 0, 0, 0, 0, 0, 0, 0, 0, 0,
3371 0, 0, 0, 0, 0, 0, 0, 0,
3373 "lwindow", /* VK_LWIN 0x5B */
3374 "rwindow", /* VK_RWIN 0x5C */
3375 "apps", /* VK_APPS 0x5D */
3377 0, 0, /* 0x5E .. 0x5F */
3379 "kp-0", /* VK_NUMPAD0 0x60 */
3380 "kp-1", /* VK_NUMPAD1 0x61 */
3381 "kp-2", /* VK_NUMPAD2 0x62 */
3382 "kp-3", /* VK_NUMPAD3 0x63 */
3383 "kp-4", /* VK_NUMPAD4 0x64 */
3384 "kp-5", /* VK_NUMPAD5 0x65 */
3385 "kp-6", /* VK_NUMPAD6 0x66 */
3386 "kp-7", /* VK_NUMPAD7 0x67 */
3387 "kp-8", /* VK_NUMPAD8 0x68 */
3388 "kp-9", /* VK_NUMPAD9 0x69 */
3389 "kp-multiply", /* VK_MULTIPLY 0x6A */
3390 "kp-add", /* VK_ADD 0x6B */
3391 "kp-separator", /* VK_SEPARATOR 0x6C */
3392 "kp-subtract", /* VK_SUBTRACT 0x6D */
3393 "kp-decimal", /* VK_DECIMAL 0x6E */
3394 "kp-divide", /* VK_DIVIDE 0x6F */
3395 "f1", /* VK_F1 0x70 */
3396 "f2", /* VK_F2 0x71 */
3397 "f3", /* VK_F3 0x72 */
3398 "f4", /* VK_F4 0x73 */
3399 "f5", /* VK_F5 0x74 */
3400 "f6", /* VK_F6 0x75 */
3401 "f7", /* VK_F7 0x76 */
3402 "f8", /* VK_F8 0x77 */
3403 "f9", /* VK_F9 0x78 */
3404 "f10", /* VK_F10 0x79 */
3405 "f11", /* VK_F11 0x7A */
3406 "f12", /* VK_F12 0x7B */
3407 "f13", /* VK_F13 0x7C */
3408 "f14", /* VK_F14 0x7D */
3409 "f15", /* VK_F15 0x7E */
3410 "f16", /* VK_F16 0x7F */
3411 "f17", /* VK_F17 0x80 */
3412 "f18", /* VK_F18 0x81 */
3413 "f19", /* VK_F19 0x82 */
3414 "f20", /* VK_F20 0x83 */
3415 "f21", /* VK_F21 0x84 */
3416 "f22", /* VK_F22 0x85 */
3417 "f23", /* VK_F23 0x86 */
3418 "f24", /* VK_F24 0x87 */
3420 0, 0, 0, 0, /* 0x88 .. 0x8B */
3421 0, 0, 0, 0, /* 0x8C .. 0x8F */
3423 "kp-numlock", /* VK_NUMLOCK 0x90 */
3424 "scroll", /* VK_SCROLL 0x91 */
3426 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
3427 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
3428 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
3429 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
3430 "kp-end", /* VK_NUMPAD_END 0x96 */
3431 "kp-home", /* VK_NUMPAD_HOME 0x97 */
3432 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
3433 "kp-up", /* VK_NUMPAD_UP 0x99 */
3434 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
3435 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
3436 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
3437 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
3439 0, 0, /* 0x9E .. 0x9F */
3442 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
3443 * Used only as parameters to GetAsyncKeyState() and GetKeyState().
3444 * No other API or message will distinguish left and right keys this way.
3448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3449 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3450 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3451 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3452 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3458 "attn", /* VK_ATTN 0xF6 */
3459 "crsel", /* VK_CRSEL 0xF7 */
3460 "exsel", /* VK_EXSEL 0xF8 */
3461 "ereof", /* VK_EREOF 0xF9 */
3462 "play", /* VK_PLAY 0xFA */
3463 "zoom", /* VK_ZOOM 0xFB */
3464 "noname", /* VK_NONAME 0xFC */
3465 "pa1", /* VK_PA1 0xFD */
3466 "oem_clear", /* VK_OEM_CLEAR 0xFE */
3469 #else /* not HAVE_NTGUI */
3472 static char *lispy_kana_keys
[] =
3474 /* X Keysym value */
3475 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
3476 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
3477 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
3478 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
3479 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
3480 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
3481 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
3482 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
3483 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
3484 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
3485 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
3486 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
3487 "kana-i", "kana-u", "kana-e", "kana-o",
3488 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
3489 "prolongedsound", "kana-A", "kana-I", "kana-U",
3490 "kana-E", "kana-O", "kana-KA", "kana-KI",
3491 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
3492 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
3493 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
3494 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
3495 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
3496 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
3497 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
3498 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
3499 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
3500 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
3501 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
3502 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
3504 #endif /* XK_kana_A */
3506 #define FUNCTION_KEY_OFFSET 0xff00
3508 /* You'll notice that this table is arranged to be conveniently
3509 indexed by X Windows keysym values. */
3510 static char *lispy_function_keys
[] =
3512 /* X Keysym value */
3514 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00 */
3522 0, 0, 0, /* 0xff10 */
3524 0, 0, 0, 0, 0, 0, 0,
3527 0, "kanji", "muhenkan",
3528 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff20...2f */
3529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff30...3f */
3530 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
3532 "home", /* 0xff50 */ /* IsCursorKey */
3543 "select", /* 0xff60 */ /* IsMiscFunctionKey */
3554 "break", /* 0xff6b */
3556 0, 0, 0, 0, 0, 0, 0, 0, "backtab", 0,
3558 0, 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff7f */
3559 "kp-space", /* 0xff80 */ /* IsKeypadKey */
3560 0, 0, 0, 0, 0, 0, 0, 0,
3561 "kp-tab", /* 0xff89 */
3563 "kp-enter", /* 0xff8d */
3565 "kp-f1", /* 0xff91 */
3569 "kp-home", /* 0xff95 */
3574 "kp-prior", /* kp-page-up */
3575 "kp-next", /* kp-page-down */
3581 0, 0, 0, 0, 0, 0, 0, 0, 0,
3582 "kp-multiply", /* 0xffaa */
3587 "kp-divide", /* 0xffaf */
3588 "kp-0", /* 0xffb0 */
3589 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
3592 "kp-equal", /* 0xffbd */
3593 "f1", /* 0xffbe */ /* IsFunctionKey */
3595 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
3596 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
3597 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
3598 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
3599 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
3600 0, 0, 0, 0, 0, 0, 0, 0,
3601 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
3602 0, 0, 0, 0, 0, 0, 0, "delete"
3605 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
3606 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
3608 static char *iso_lispy_function_keys
[] =
3610 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
3611 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
3612 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
3613 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
3614 "iso-lefttab", /* 0xfe20 */
3615 "iso-move-line-up", "iso-move-line-down",
3616 "iso-partial-line-up", "iso-partial-line-down",
3617 "iso-partial-space-left", "iso-partial-space-right",
3618 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
3619 "iso-release-margin-left", "iso-release-margin-right",
3620 "iso-release-both-margins",
3621 "iso-fast-cursor-left", "iso-fast-cursor-right",
3622 "iso-fast-cursor-up", "iso-fast-cursor-down",
3623 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
3624 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
3627 #endif /* not HAVE_NTGUI */
3629 static char *lispy_mouse_names
[] =
3631 "mouse-1", "mouse-2", "mouse-3", "mouse-4", "mouse-5"
3634 /* Scroll bar parts. */
3635 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
3636 Lisp_Object Qup
, Qdown
;
3638 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
3639 Lisp_Object
*scroll_bar_parts
[] = {
3640 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
3645 /* A vector, indexed by button number, giving the down-going location
3646 of currently depressed buttons, both scroll bar and non-scroll bar.
3648 The elements have the form
3649 (BUTTON-NUMBER MODIFIER-MASK . REST)
3650 where REST is the cdr of a position as it would be reported in the event.
3652 The make_lispy_event function stores positions here to tell the
3653 difference between click and drag events, and to store the starting
3654 location to be included in drag events. */
3656 static Lisp_Object button_down_location
;
3658 /* Information about the most recent up-going button event: Which
3659 button, what location, and what time. */
3661 static int last_mouse_button
;
3662 static int last_mouse_x
;
3663 static int last_mouse_y
;
3664 static unsigned long button_down_time
;
3666 /* The maximum time between clicks to make a double-click,
3667 or Qnil to disable double-click detection,
3668 or Qt for no time limit. */
3669 Lisp_Object Vdouble_click_time
;
3671 /* The number of clicks in this multiple-click. */
3673 int double_click_count
;
3675 /* Given a struct input_event, build the lisp event which represents
3676 it. If EVENT is 0, build a mouse movement event from the mouse
3677 movement buffer, which should have a movement event in it.
3679 Note that events must be passed to this function in the order they
3680 are received; this function stores the location of button presses
3681 in order to build drag events when the button is released. */
3684 make_lispy_event (event
)
3685 struct input_event
*event
;
3689 switch (SWITCH_ENUM_CAST (event
->kind
))
3691 /* A simple keystroke. */
3692 case ascii_keystroke
:
3694 Lisp_Object lispy_c
;
3695 int c
= event
->code
& 0377;
3696 /* Turn ASCII characters into control characters
3698 if (event
->modifiers
& ctrl_modifier
)
3699 c
= make_ctrl_char (c
);
3701 /* Add in the other modifier bits. We took care of ctrl_modifier
3702 just above, and the shift key was taken care of by the X code,
3703 and applied to control characters by make_ctrl_char. */
3704 c
|= (event
->modifiers
3705 & (meta_modifier
| alt_modifier
3706 | hyper_modifier
| super_modifier
));
3707 /* Distinguish Shift-SPC from SPC. */
3708 if ((event
->code
& 0377) == 040
3709 && event
->modifiers
& shift_modifier
)
3710 c
|= shift_modifier
;
3711 button_down_time
= 0;
3712 XSETFASTINT (lispy_c
, c
);
3716 /* A function key. The symbol may need to have modifier prefixes
3718 case non_ascii_keystroke
:
3719 button_down_time
= 0;
3721 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
3722 if (event
->code
== lispy_accent_codes
[i
])
3723 return modify_event_symbol (i
,
3725 Qfunction_key
, Qnil
,
3726 lispy_accent_keys
, &accent_key_syms
,
3727 (sizeof (lispy_accent_keys
)
3728 / sizeof (lispy_accent_keys
[0])));
3730 /* Handle system-specific keysyms. */
3731 if (event
->code
& (1 << 28))
3733 /* We need to use an alist rather than a vector as the cache
3734 since we can't make a vector long enuf. */
3735 if (NILP (current_kboard
->system_key_syms
))
3736 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
3737 return modify_event_symbol (event
->code
,
3740 current_kboard
->Vsystem_key_alist
,
3741 0, ¤t_kboard
->system_key_syms
,
3746 if (event
->code
>= 0x400 && event
->code
< 0x500)
3747 return modify_event_symbol (event
->code
- 0x400,
3748 event
->modifiers
& ~shift_modifier
,
3749 Qfunction_key
, Qnil
,
3750 lispy_kana_keys
, &func_key_syms
,
3751 (sizeof (lispy_kana_keys
)
3752 / sizeof (lispy_kana_keys
[0])));
3753 #endif /* XK_kana_A */
3755 #ifdef ISO_FUNCTION_KEY_OFFSET
3756 if (event
->code
< FUNCTION_KEY_OFFSET
3757 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
3758 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
3760 Qfunction_key
, Qnil
,
3761 iso_lispy_function_keys
, &func_key_syms
,
3762 (sizeof (iso_lispy_function_keys
)
3763 / sizeof (iso_lispy_function_keys
[0])));
3766 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
3768 Qfunction_key
, Qnil
,
3769 lispy_function_keys
, &func_key_syms
,
3770 (sizeof (lispy_function_keys
)
3771 / sizeof (lispy_function_keys
[0])));
3774 /* A mouse click. Figure out where it is, decide whether it's
3775 a press, click or drag, and build the appropriate structure. */
3777 case scroll_bar_click
:
3779 int button
= event
->code
;
3781 Lisp_Object position
;
3782 Lisp_Object
*start_pos_ptr
;
3783 Lisp_Object start_pos
;
3785 if (button
< 0 || button
>= NUM_MOUSE_BUTTONS
)
3788 /* Build the position as appropriate for this mouse click. */
3789 if (event
->kind
== mouse_click
)
3792 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
3797 /* Ignore mouse events that were made on frame that
3798 have been deleted. */
3799 if (! FRAME_LIVE_P (f
))
3802 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
3803 &column
, &row
, NULL
, 1);
3805 #ifndef USE_X_TOOLKIT
3806 /* In the non-toolkit version, clicks on the menu bar
3807 are ordinary button events in the event buffer.
3808 Distinguish them, and invoke the menu.
3810 (In the toolkit version, the toolkit handles the menu bar
3811 and Emacs doesn't know about it until after the user
3812 makes a selection.) */
3813 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
3814 && (event
->modifiers
& down_modifier
))
3816 Lisp_Object items
, item
;
3821 /* Activate the menu bar on the down event. If the
3822 up event comes in before the menu code can deal with it,
3824 if (! (event
->modifiers
& down_modifier
))
3829 items
= FRAME_MENU_BAR_ITEMS (f
);
3830 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
3832 Lisp_Object pos
, string
;
3833 string
= XVECTOR (items
)->contents
[i
+ 1];
3834 pos
= XVECTOR (items
)->contents
[i
+ 3];
3837 if (column
>= XINT (pos
)
3838 && column
< XINT (pos
) + XSTRING (string
)->size
)
3840 item
= XVECTOR (items
)->contents
[i
];
3846 = Fcons (event
->frame_or_window
,
3848 Fcons (Fcons (event
->x
, event
->y
),
3849 Fcons (make_number (event
->timestamp
),
3852 return Fcons (item
, Fcons (position
, Qnil
));
3854 #endif /* not USE_X_TOOLKIT */
3856 window
= window_from_coordinates (f
, column
, row
, &part
);
3858 if (!WINDOWP (window
))
3860 window
= event
->frame_or_window
;
3865 int pixcolumn
, pixrow
;
3866 column
-= WINDOW_LEFT_MARGIN (XWINDOW (window
));
3867 row
-= XINT (XWINDOW (window
)->top
);
3868 glyph_to_pixel_coords (f
, column
, row
, &pixcolumn
, &pixrow
);
3869 XSETINT (event
->x
, pixcolumn
);
3870 XSETINT (event
->y
, pixrow
);
3875 posn
= Qvertical_line
;
3878 buffer_posn_from_coords (XWINDOW (window
),
3885 Fcons (Fcons (event
->x
, event
->y
),
3886 Fcons (make_number (event
->timestamp
),
3892 Lisp_Object portion_whole
;
3895 window
= event
->frame_or_window
;
3896 portion_whole
= Fcons (event
->x
, event
->y
);
3897 part
= *scroll_bar_parts
[(int) event
->part
];
3901 Fcons (Qvertical_scroll_bar
,
3902 Fcons (portion_whole
,
3903 Fcons (make_number (event
->timestamp
),
3904 Fcons (part
, Qnil
)))));
3907 start_pos_ptr
= &XVECTOR (button_down_location
)->contents
[button
];
3909 start_pos
= *start_pos_ptr
;
3910 *start_pos_ptr
= Qnil
;
3912 is_double
= (button
== last_mouse_button
3913 && XINT (event
->x
) == last_mouse_x
3914 && XINT (event
->y
) == last_mouse_y
3915 && button_down_time
!= 0
3916 && (EQ (Vdouble_click_time
, Qt
)
3917 || (INTEGERP (Vdouble_click_time
)
3918 && ((int)(event
->timestamp
- button_down_time
)
3919 < XINT (Vdouble_click_time
)))));
3920 last_mouse_button
= button
;
3921 last_mouse_x
= XINT (event
->x
);
3922 last_mouse_y
= XINT (event
->y
);
3924 /* If this is a button press, squirrel away the location, so
3925 we can decide later whether it was a click or a drag. */
3926 if (event
->modifiers
& down_modifier
)
3930 double_click_count
++;
3931 event
->modifiers
|= ((double_click_count
> 2)
3936 double_click_count
= 1;
3937 button_down_time
= event
->timestamp
;
3938 *start_pos_ptr
= Fcopy_alist (position
);
3941 /* Now we're releasing a button - check the co-ordinates to
3942 see if this was a click or a drag. */
3943 else if (event
->modifiers
& up_modifier
)
3945 /* If we did not see a down before this up,
3946 ignore the up. Probably this happened because
3947 the down event chose a menu item.
3948 It would be an annoyance to treat the release
3949 of the button that chose the menu item
3950 as a separate event. */
3952 if (!CONSP (start_pos
))
3955 event
->modifiers
&= ~up_modifier
;
3956 #if 0 /* Formerly we treated an up with no down as a click event. */
3957 if (!CONSP (start_pos
))
3958 event
->modifiers
|= click_modifier
;
3962 /* The third element of every position should be the (x,y)
3966 down
= Fnth (make_number (2), start_pos
);
3967 if (EQ (event
->x
, XCONS (down
)->car
)
3968 && EQ (event
->y
, XCONS (down
)->cdr
))
3970 event
->modifiers
|= click_modifier
;
3974 button_down_time
= 0;
3975 event
->modifiers
|= drag_modifier
;
3977 /* Don't check is_double; treat this as multiple
3978 if the down-event was multiple. */
3979 if (double_click_count
> 1)
3980 event
->modifiers
|= ((double_click_count
> 2)
3986 /* Every mouse event should either have the down_modifier or
3987 the up_modifier set. */
3991 /* Get the symbol we should use for the mouse click. */
3994 head
= modify_event_symbol (button
,
3997 lispy_mouse_names
, &mouse_syms
,
3998 (sizeof (lispy_mouse_names
)
3999 / sizeof (lispy_mouse_names
[0])));
4000 if (event
->modifiers
& drag_modifier
)
4005 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
4008 Fcons (make_number (double_click_count
),
4018 case w32_scroll_bar_click
:
4020 int button
= event
->code
;
4022 Lisp_Object position
;
4023 Lisp_Object
*start_pos_ptr
;
4024 Lisp_Object start_pos
;
4026 if (button
< 0 || button
>= NUM_MOUSE_BUTTONS
)
4031 Lisp_Object portion_whole
;
4034 window
= event
->frame_or_window
;
4035 portion_whole
= Fcons (event
->x
, event
->y
);
4036 part
= *scroll_bar_parts
[(int) event
->part
];
4040 Fcons (Qvertical_scroll_bar
,
4041 Fcons (portion_whole
,
4042 Fcons (make_number (event
->timestamp
),
4043 Fcons (part
, Qnil
)))));
4046 /* Always treat W32 scroll bar events as clicks. */
4047 event
->modifiers
|= click_modifier
;
4050 /* Get the symbol we should use for the mouse click. */
4053 head
= modify_event_symbol (button
,
4056 lispy_mouse_names
, &mouse_syms
,
4057 (sizeof (lispy_mouse_names
)
4058 / sizeof (lispy_mouse_names
[0])));
4066 #endif /* HAVE_MOUSE */
4068 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
4069 case menu_bar_event
:
4070 /* The event value is in the cdr of the frame_or_window slot. */
4071 if (!CONSP (event
->frame_or_window
))
4073 return XCONS (event
->frame_or_window
)->cdr
;
4076 /* The 'kind' field of the event is something we don't recognize. */
4085 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
4087 Lisp_Object bar_window
;
4088 enum scroll_bar_part part
;
4092 /* Is it a scroll bar movement? */
4093 if (frame
&& ! NILP (bar_window
))
4095 Lisp_Object part_sym
;
4097 part_sym
= *scroll_bar_parts
[(int) part
];
4098 return Fcons (Qscroll_bar_movement
,
4099 (Fcons (Fcons (bar_window
,
4100 Fcons (Qvertical_scroll_bar
,
4101 Fcons (Fcons (x
, y
),
4102 Fcons (make_number (time
),
4108 /* Or is it an ordinary mouse movement? */
4118 /* It's in a frame; which window on that frame? */
4119 pixel_to_glyph_coords (frame
, XINT (x
), XINT (y
), &column
, &row
,
4121 window
= window_from_coordinates (frame
, column
, row
, &area
);
4126 if (WINDOWP (window
))
4128 int pixcolumn
, pixrow
;
4129 column
-= WINDOW_LEFT_MARGIN (XWINDOW (window
));
4130 row
-= XINT (XWINDOW (window
)->top
);
4131 glyph_to_pixel_coords (frame
, column
, row
, &pixcolumn
, &pixrow
);
4132 XSETINT (x
, pixcolumn
);
4133 XSETINT (y
, pixrow
);
4138 posn
= Qvertical_line
;
4141 buffer_posn_from_coords (XWINDOW (window
), column
, row
));
4143 else if (frame
!= 0)
4145 XSETFRAME (window
, frame
);
4156 return Fcons (Qmouse_movement
,
4157 Fcons (Fcons (window
,
4159 Fcons (Fcons (x
, y
),
4160 Fcons (make_number (time
),
4166 #endif /* HAVE_MOUSE */
4168 /* Construct a switch frame event. */
4170 make_lispy_switch_frame (frame
)
4173 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
4176 /* Manipulating modifiers. */
4178 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
4180 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
4181 SYMBOL's name of the end of the modifiers; the string from this
4182 position is the unmodified symbol name.
4184 This doesn't use any caches. */
4187 parse_modifiers_uncached (symbol
, modifier_end
)
4191 struct Lisp_String
*name
;
4195 CHECK_SYMBOL (symbol
, 1);
4198 name
= XSYMBOL (symbol
)->name
;
4200 for (i
= 0; i
+2 <= name
->size
; )
4202 int this_mod_end
= 0;
4205 /* See if the name continues with a modifier word.
4206 Check that the word appears, but don't check what follows it.
4207 Set this_mod and this_mod_end to record what we find. */
4209 switch (name
->data
[i
])
4211 #define SINGLE_LETTER_MOD(BIT) \
4212 (this_mod_end = i + 1, this_mod = BIT)
4215 SINGLE_LETTER_MOD (alt_modifier
);
4219 SINGLE_LETTER_MOD (ctrl_modifier
);
4223 SINGLE_LETTER_MOD (hyper_modifier
);
4227 SINGLE_LETTER_MOD (meta_modifier
);
4231 SINGLE_LETTER_MOD (shift_modifier
);
4235 SINGLE_LETTER_MOD (super_modifier
);
4238 #undef SINGLE_LETTER_MOD
4241 /* If we found no modifier, stop looking for them. */
4242 if (this_mod_end
== 0)
4245 /* Check there is a dash after the modifier, so that it
4246 really is a modifier. */
4247 if (this_mod_end
>= name
->size
|| name
->data
[this_mod_end
] != '-')
4250 /* This modifier is real; look for another. */
4251 modifiers
|= this_mod
;
4252 i
= this_mod_end
+ 1;
4255 /* Should we include the `click' modifier? */
4256 if (! (modifiers
& (down_modifier
| drag_modifier
4257 | double_modifier
| triple_modifier
))
4258 && i
+ 7 == name
->size
4259 && strncmp (name
->data
+ i
, "mouse-", 6) == 0
4260 && ('0' <= name
->data
[i
+ 6] && name
->data
[i
+ 6] <= '9'))
4261 modifiers
|= click_modifier
;
4269 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
4270 prepended to the string BASE[0..BASE_LEN-1].
4271 This doesn't use any caches. */
4273 apply_modifiers_uncached (modifiers
, base
, base_len
)
4278 /* Since BASE could contain nulls, we can't use intern here; we have
4279 to use Fintern, which expects a genuine Lisp_String, and keeps a
4282 (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
4288 /* Only the event queue may use the `up' modifier; it should always
4289 be turned into a click or drag event before presented to lisp code. */
4290 if (modifiers
& up_modifier
)
4293 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
4294 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
4295 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
4296 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
4297 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
4298 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
4299 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
4300 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
4301 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
4302 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
4303 /* The click modifier is denoted by the absence of other modifiers. */
4307 mod_len
= p
- new_mods
;
4311 Lisp_Object new_name
;
4313 new_name
= make_uninit_string (mod_len
+ base_len
);
4314 bcopy (new_mods
, XSTRING (new_name
)->data
, mod_len
);
4315 bcopy (base
, XSTRING (new_name
)->data
+ mod_len
, base_len
);
4317 return Fintern (new_name
, Qnil
);
4322 static char *modifier_names
[] =
4324 "up", "down", "drag", "click", "double", "triple", 0, 0,
4325 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4326 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
4328 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
4330 static Lisp_Object modifier_symbols
;
4332 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
4334 lispy_modifier_list (modifiers
)
4337 Lisp_Object modifier_list
;
4340 modifier_list
= Qnil
;
4341 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
4342 if (modifiers
& (1<<i
))
4343 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
4346 return modifier_list
;
4350 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
4351 where UNMODIFIED is the unmodified form of SYMBOL,
4352 MASK is the set of modifiers present in SYMBOL's name.
4353 This is similar to parse_modifiers_uncached, but uses the cache in
4354 SYMBOL's Qevent_symbol_element_mask property, and maintains the
4355 Qevent_symbol_elements property. */
4358 parse_modifiers (symbol
)
4361 Lisp_Object elements
;
4363 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
4364 if (CONSP (elements
))
4369 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
4370 Lisp_Object unmodified
;
4373 unmodified
= Fintern (make_string (XSYMBOL (symbol
)->name
->data
+ end
,
4374 XSYMBOL (symbol
)->name
->size
- end
),
4377 if (modifiers
& ~(((EMACS_INT
)1 << VALBITS
) - 1))
4379 XSETFASTINT (mask
, modifiers
);
4380 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
4382 /* Cache the parsing results on SYMBOL. */
4383 Fput (symbol
, Qevent_symbol_element_mask
,
4385 Fput (symbol
, Qevent_symbol_elements
,
4386 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
4388 /* Since we know that SYMBOL is modifiers applied to unmodified,
4389 it would be nice to put that in unmodified's cache.
4390 But we can't, since we're not sure that parse_modifiers is
4397 /* Apply the modifiers MODIFIERS to the symbol BASE.
4398 BASE must be unmodified.
4400 This is like apply_modifiers_uncached, but uses BASE's
4401 Qmodifier_cache property, if present. It also builds
4402 Qevent_symbol_elements properties, since it has that info anyway.
4404 apply_modifiers copies the value of BASE's Qevent_kind property to
4405 the modified symbol. */
4407 apply_modifiers (modifiers
, base
)
4411 Lisp_Object cache
, index
, entry
, new_symbol
;
4413 /* Mask out upper bits. We don't know where this value's been. */
4414 modifiers
&= ((EMACS_INT
)1 << VALBITS
) - 1;
4416 /* The click modifier never figures into cache indices. */
4417 cache
= Fget (base
, Qmodifier_cache
);
4418 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
4419 entry
= assq_no_quit (index
, cache
);
4422 new_symbol
= XCONS (entry
)->cdr
;
4425 /* We have to create the symbol ourselves. */
4426 new_symbol
= apply_modifiers_uncached (modifiers
,
4427 XSYMBOL (base
)->name
->data
,
4428 XSYMBOL (base
)->name
->size
);
4430 /* Add the new symbol to the base's cache. */
4431 entry
= Fcons (index
, new_symbol
);
4432 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
4434 /* We have the parsing info now for free, so add it to the caches. */
4435 XSETFASTINT (index
, modifiers
);
4436 Fput (new_symbol
, Qevent_symbol_element_mask
,
4437 Fcons (base
, Fcons (index
, Qnil
)));
4438 Fput (new_symbol
, Qevent_symbol_elements
,
4439 Fcons (base
, lispy_modifier_list (modifiers
)));
4442 /* Make sure this symbol is of the same kind as BASE.
4444 You'd think we could just set this once and for all when we
4445 intern the symbol above, but reorder_modifiers may call us when
4446 BASE's property isn't set right; we can't assume that just
4447 because it has a Qmodifier_cache property it must have its
4448 Qevent_kind set right as well. */
4449 if (NILP (Fget (new_symbol
, Qevent_kind
)))
4453 kind
= Fget (base
, Qevent_kind
);
4455 Fput (new_symbol
, Qevent_kind
, kind
);
4462 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
4463 return a symbol with the modifiers placed in the canonical order.
4464 Canonical order is alphabetical, except for down and drag, which
4465 always come last. The 'click' modifier is never written out.
4467 Fdefine_key calls this to make sure that (for example) C-M-foo
4468 and M-C-foo end up being equivalent in the keymap. */
4471 reorder_modifiers (symbol
)
4474 /* It's hopefully okay to write the code this way, since everything
4475 will soon be in caches, and no consing will be done at all. */
4478 parsed
= parse_modifiers (symbol
);
4479 return apply_modifiers ((int) XINT (XCONS (XCONS (parsed
)->cdr
)->car
),
4480 XCONS (parsed
)->car
);
4484 /* For handling events, we often want to produce a symbol whose name
4485 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
4486 to some base, like the name of a function key or mouse button.
4487 modify_event_symbol produces symbols of this sort.
4489 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
4490 is the name of the i'th symbol. TABLE_SIZE is the number of elements
4493 Alternatively, NAME_ALIST is an alist mapping codes into symbol names.
4494 NAME_ALIST is used if it is non-nil; otherwise NAME_TABLE is used.
4496 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
4497 persist between calls to modify_event_symbol that it can use to
4498 store a cache of the symbols it's generated for this NAME_TABLE
4499 before. The object stored there may be a vector or an alist.
4501 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
4503 MODIFIERS is a set of modifier bits (as given in struct input_events)
4504 whose prefixes should be applied to the symbol name.
4506 SYMBOL_KIND is the value to be placed in the event_kind property of
4507 the returned symbol.
4509 The symbols we create are supposed to have an
4510 `event-symbol-elements' property, which lists the modifiers present
4511 in the symbol's name. */
4514 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist
,
4515 name_table
, symbol_table
, table_size
)
4518 Lisp_Object symbol_kind
;
4519 Lisp_Object name_alist
;
4521 Lisp_Object
*symbol_table
;
4522 unsigned int table_size
;
4525 Lisp_Object symbol_int
;
4527 /* Get rid of the "vendor-specific" bit here. */
4528 XSETINT (symbol_int
, symbol_num
& 0xffffff);
4530 /* Is this a request for a valid symbol? */
4531 if (symbol_num
< 0 || symbol_num
>= table_size
)
4534 if (CONSP (*symbol_table
))
4535 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
4537 /* If *symbol_table doesn't seem to be initialized properly, fix that.
4538 *symbol_table should be a lisp vector TABLE_SIZE elements long,
4539 where the Nth element is the symbol for NAME_TABLE[N], or nil if
4540 we've never used that symbol before. */
4543 if (! VECTORP (*symbol_table
)
4544 || XVECTOR (*symbol_table
)->size
!= table_size
)
4548 XSETFASTINT (size
, table_size
);
4549 *symbol_table
= Fmake_vector (size
, Qnil
);
4552 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
4555 /* Have we already used this symbol before? */
4558 /* No; let's create it. */
4559 if (!NILP (name_alist
))
4560 value
= Fcdr_safe (Fassq (symbol_int
, name_alist
));
4561 else if (name_table
!= 0 && name_table
[symbol_num
])
4562 value
= intern (name_table
[symbol_num
]);
4564 #ifdef HAVE_WINDOW_SYSTEM
4567 char *name
= x_get_keysym_name (symbol_num
);
4569 value
= intern (name
);
4576 sprintf (buf
, "key-%d", symbol_num
);
4577 value
= intern (buf
);
4580 if (CONSP (*symbol_table
))
4581 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
4583 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
4585 /* Fill in the cache entries for this symbol; this also
4586 builds the Qevent_symbol_elements property, which the user
4588 apply_modifiers (modifiers
& click_modifier
, value
);
4589 Fput (value
, Qevent_kind
, symbol_kind
);
4592 /* Apply modifiers to that symbol. */
4593 return apply_modifiers (modifiers
, value
);
4596 /* Convert a list that represents an event type,
4597 such as (ctrl meta backspace), into the usual representation of that
4598 event type as a number or a symbol. */
4600 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
4601 "Convert the event description list EVENT-DESC to an event type.\n\
4602 EVENT-DESC should contain one base event type (a character or symbol)\n\
4603 and zero or more modifier names (control, meta, hyper, super, shift, alt,\n\
4604 drag, down, double or triple). The base must be last.\n\
4605 The return value is an event type (a character or symbol) which\n\
4606 has the same base event type and all the specified modifiers.")
4608 Lisp_Object event_desc
;
4616 while (CONSP (rest
))
4621 elt
= XCONS (rest
)->car
;
4622 rest
= XCONS (rest
)->cdr
;
4624 /* Given a symbol, see if it is a modifier name. */
4625 if (SYMBOLP (elt
) && CONSP (rest
))
4626 this = parse_solitary_modifier (elt
);
4630 else if (!NILP (base
))
4631 error ("Two bases given in one event");
4637 /* Let the symbol A refer to the character A. */
4638 if (SYMBOLP (base
) && XSYMBOL (base
)->name
->size
== 1)
4639 XSETINT (base
, XSYMBOL (base
)->name
->data
[0]);
4641 if (INTEGERP (base
))
4643 /* Turn (shift a) into A. */
4644 if ((modifiers
& shift_modifier
) != 0
4645 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
4647 XSETINT (base
, XINT (base
) - ('a' - 'A'));
4648 modifiers
&= ~shift_modifier
;
4651 /* Turn (control a) into C-a. */
4652 if (modifiers
& ctrl_modifier
)
4653 return make_number ((modifiers
& ~ctrl_modifier
)
4654 | make_ctrl_char (XINT (base
)));
4656 return make_number (modifiers
| XINT (base
));
4658 else if (SYMBOLP (base
))
4659 return apply_modifiers (modifiers
, base
);
4661 error ("Invalid base event");
4664 /* Try to recognize SYMBOL as a modifier name.
4665 Return the modifier flag bit, or 0 if not recognized. */
4668 parse_solitary_modifier (symbol
)
4671 struct Lisp_String
*name
= XSYMBOL (symbol
)->name
;
4673 switch (name
->data
[0])
4675 #define SINGLE_LETTER_MOD(BIT) \
4676 if (name->size == 1) \
4679 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
4680 if (LEN == name->size \
4681 && ! strncmp (name->data, NAME, LEN)) \
4685 SINGLE_LETTER_MOD (alt_modifier
);
4689 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
4693 SINGLE_LETTER_MOD (ctrl_modifier
);
4697 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
4698 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
4702 SINGLE_LETTER_MOD (hyper_modifier
);
4706 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
4710 SINGLE_LETTER_MOD (meta_modifier
);
4714 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
4718 SINGLE_LETTER_MOD (shift_modifier
);
4722 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
4723 MULTI_LETTER_MOD (super_modifier
, "super", 5);
4724 SINGLE_LETTER_MOD (super_modifier
);
4728 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
4729 MULTI_LETTER_MOD (down_modifier
, "down", 4);
4730 MULTI_LETTER_MOD (double_modifier
, "double", 6);
4734 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
4737 #undef SINGLE_LETTER_MOD
4738 #undef MULTI_LETTER_MOD
4744 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
4745 Such a list is not valid as an event,
4746 but it can be a Lucid-style event type list. */
4749 lucid_event_type_list_p (object
)
4754 if (! CONSP (object
))
4757 for (tail
= object
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
4760 elt
= XCONS (tail
)->car
;
4761 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
4768 /* Store into *addr a value nonzero if terminal input chars are available.
4769 Serves the purpose of ioctl (0, FIONREAD, addr)
4770 but works even if FIONREAD does not exist.
4771 (In fact, this may actually read some input.)
4773 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
4776 get_input_pending (addr
, do_timers_now
)
4780 /* First of all, have we already counted some input? */
4781 *addr
= !NILP (Vquit_flag
) || readable_events (do_timers_now
);
4783 /* If input is being read as it arrives, and we have none, there is none. */
4784 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
4787 /* Try to read some input and see how much we get. */
4789 *addr
= !NILP (Vquit_flag
) || readable_events (do_timers_now
);
4792 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
4795 gobble_input (expected
)
4800 if (interrupt_input
)
4803 mask
= sigblock (sigmask (SIGIO
));
4804 read_avail_input (expected
);
4808 #ifdef POLL_FOR_INPUT
4809 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
4812 mask
= sigblock (sigmask (SIGALRM
));
4813 read_avail_input (expected
);
4819 read_avail_input (expected
);
4823 /* Put a buffer_switch_event in the buffer
4824 so that read_key_sequence will notice the new current buffer. */
4826 record_asynch_buffer_change ()
4828 struct input_event event
;
4831 event
.kind
= buffer_switch_event
;
4832 event
.frame_or_window
= Qnil
;
4835 /* We don't need a buffer-switch event unless Emacs is waiting for input.
4836 The purpose of the event is to make read_key_sequence look up the
4837 keymaps again. If we aren't in read_key_sequence, we don't need one,
4838 and the event could cause trouble by messing up (input-pending-p). */
4839 tem
= Fwaiting_for_user_input_p ();
4843 /* We never need these events if we have no asynchronous subprocesses. */
4847 /* Make sure no interrupt happens while storing the event. */
4849 if (interrupt_input
)
4852 mask
= sigblock (sigmask (SIGIO
));
4853 kbd_buffer_store_event (&event
);
4860 kbd_buffer_store_event (&event
);
4867 /* Read any terminal input already buffered up by the system
4868 into the kbd_buffer, but do not wait.
4870 EXPECTED should be nonzero if the caller knows there is some input.
4872 Except on VMS, all input is read by this function.
4873 If interrupt_input is nonzero, this function MUST be called
4874 only when SIGIO is blocked.
4876 Returns the number of keyboard chars read, or -1 meaning
4877 this is a bad time to try to read input. */
4880 read_avail_input (expected
)
4883 struct input_event buf
[KBD_BUFFER_SIZE
];
4887 if (read_socket_hook
)
4888 /* No need for FIONREAD or fcntl; just say don't wait. */
4889 nread
= (*read_socket_hook
) (input_fd
, buf
, KBD_BUFFER_SIZE
, expected
);
4892 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
4893 the kbd_buffer can really hold. That may prevent loss
4894 of characters on some systems when input is stuffed at us. */
4895 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
4898 /* Determine how many characters we should *try* to read. */
4901 #else /* not WINDOWSNT */
4903 n_to_read
= dos_keysns ();
4906 #else /* not MSDOS */
4908 /* Find out how much input is available. */
4909 if (ioctl (input_fd
, FIONREAD
, &n_to_read
) < 0)
4910 /* Formerly simply reported no input, but that sometimes led to
4911 a failure of Emacs to terminate.
4912 SIGHUP seems appropriate if we can't reach the terminal. */
4913 /* ??? Is it really right to send the signal just to this process
4914 rather than to the whole process group?
4915 Perhaps on systems with FIONREAD Emacs is alone in its group. */
4916 kill (getpid (), SIGHUP
);
4919 if (n_to_read
> sizeof cbuf
)
4920 n_to_read
= sizeof cbuf
;
4921 #else /* no FIONREAD */
4922 #if defined (USG) || defined (DGUX)
4923 /* Read some input if available, but don't wait. */
4924 n_to_read
= sizeof cbuf
;
4925 fcntl (input_fd
, F_SETFL
, O_NDELAY
);
4930 #endif /* not MSDOS */
4931 #endif /* not WINDOWSNT */
4933 /* Now read; for one reason or another, this will not block.
4934 NREAD is set to the number of chars read. */
4938 cbuf
[0] = dos_keyread ();
4941 nread
= read (input_fd
, cbuf
, n_to_read
);
4943 /* POSIX infers that processes which are not in the session leader's
4944 process group won't get SIGHUP's at logout time. BSDI adheres to
4945 this part standard and returns -1 from read(0) with errno==EIO
4946 when the control tty is taken away.
4947 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
4948 if (nread
== -1 && errno
== EIO
)
4950 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
4951 /* The kernel sometimes fails to deliver SIGHUP for ptys.
4952 This looks incorrect, but it isn't, because _BSD causes
4953 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
4954 and that causes a value other than 0 when there is no input. */
4960 /* We used to retry the read if it was interrupted.
4961 But this does the wrong thing when O_NDELAY causes
4962 an EAGAIN error. Does anybody know of a situation
4963 where a retry is actually needed? */
4965 nread
< 0 && (errno
== EAGAIN
4979 #if defined (USG) || defined (DGUX)
4980 fcntl (input_fd
, F_SETFL
, 0);
4981 #endif /* USG or DGUX */
4982 #endif /* no FIONREAD */
4983 for (i
= 0; i
< nread
; i
++)
4985 buf
[i
].kind
= ascii_keystroke
;
4986 buf
[i
].modifiers
= 0;
4987 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
4988 buf
[i
].modifiers
= meta_modifier
;
4992 buf
[i
].code
= cbuf
[i
];
4993 XSETFRAME (buf
[i
].frame_or_window
, selected_frame
);
4997 /* Scan the chars for C-g and store them in kbd_buffer. */
4998 for (i
= 0; i
< nread
; i
++)
5000 kbd_buffer_store_event (&buf
[i
]);
5001 /* Don't look at input that follows a C-g too closely.
5002 This reduces lossage due to autorepeat on C-g. */
5003 if (buf
[i
].kind
== ascii_keystroke
5004 && buf
[i
].code
== quit_char
)
5010 #endif /* not VMS */
5012 #ifdef SIGIO /* for entire page */
5013 /* Note SIGIO has been undef'd if FIONREAD is missing. */
5016 input_available_signal (signo
)
5019 /* Must preserve main program's value of errno. */
5020 int old_errno
= errno
;
5022 extern int select_alarmed
;
5025 #if defined (USG) && !defined (POSIX_SIGNALS)
5026 /* USG systems forget handlers when they are used;
5027 must reestablish each time */
5028 signal (signo
, input_available_signal
);
5035 if (input_available_clear_time
)
5036 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
5041 nread
= read_avail_input (1);
5042 /* -1 means it's not ok to read the input now.
5043 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
5044 0 means there was no keyboard input available. */
5049 select_alarmed
= 1; /* Force the select emulator back to life */
5060 /* Send ourselves a SIGIO.
5062 This function exists so that the UNBLOCK_INPUT macro in
5063 blockinput.h can have some way to take care of input we put off
5064 dealing with, without assuming that every file which uses
5065 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
5067 reinvoke_input_signal ()
5070 kill (getpid (), SIGIO
);
5076 /* Return the prompt-string of a sparse keymap.
5077 This is the first element which is a string.
5078 Return nil if there is none. */
5086 register Lisp_Object tem
;
5095 static void menu_bar_item ();
5096 static void menu_bar_one_keymap ();
5098 /* These variables hold the vector under construction within
5099 menu_bar_items and its subroutines, and the current index
5100 for storing into that vector. */
5101 static Lisp_Object menu_bar_items_vector
;
5102 static int menu_bar_items_index
;
5104 /* Return a vector of menu items for a menu bar, appropriate
5105 to the current buffer. Each item has three elements in the vector:
5108 OLD is an old vector we can optionally reuse, or nil. */
5111 menu_bar_items (old
)
5114 /* The number of keymaps we're scanning right now, and the number of
5115 keymaps we have allocated space for. */
5118 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
5119 in the current keymaps, or nil where it is not a prefix. */
5122 Lisp_Object def
, tem
, tail
;
5131 struct gcpro gcpro1
;
5133 /* In order to build the menus, we need to call the keymap
5134 accessors. They all call QUIT. But this function is called
5135 during redisplay, during which a quit is fatal. So inhibit
5136 quitting while building the menus.
5137 We do this instead of specbind because (1) errors will clear it anyway
5138 and (2) this avoids risk of specpdl overflow. */
5139 oquit
= Vinhibit_quit
;
5143 menu_bar_items_vector
= old
;
5145 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
5146 menu_bar_items_index
= 0;
5148 GCPRO1 (menu_bar_items_vector
);
5150 /* Build our list of keymaps.
5151 If we recognize a function key and replace its escape sequence in
5152 keybuf with its symbol, or if the sequence starts with a mouse
5153 click and we need to switch buffers, we jump back here to rebuild
5154 the initial keymaps from the current buffer. */
5158 /* Should overriding-terminal-local-map and overriding-local-map apply? */
5159 if (!NILP (Voverriding_local_map_menu_flag
))
5161 /* Yes, use them (if non-nil) as well as the global map. */
5162 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
5164 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
5165 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
5166 if (!NILP (Voverriding_local_map
))
5167 maps
[nmaps
++] = Voverriding_local_map
;
5171 /* No, so use major and minor mode keymaps. */
5172 nmaps
= current_minor_maps (NULL
, &tmaps
);
5173 maps
= (Lisp_Object
*) alloca ((nmaps
+ 2) * sizeof (maps
[0]));
5174 bcopy (tmaps
, maps
, nmaps
* sizeof (maps
[0]));
5175 #ifdef USE_TEXT_PROPERTIES
5176 maps
[nmaps
++] = get_local_map (PT
, current_buffer
);
5178 maps
[nmaps
++] = current_buffer
->keymap
;
5181 maps
[nmaps
++] = current_global_map
;
5184 /* Look up in each map the dummy prefix key `menu-bar'. */
5188 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
5190 if (! NILP (maps
[mapno
]))
5191 def
= get_keyelt (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0), 0);
5195 tem
= Fkeymapp (def
);
5197 menu_bar_one_keymap (def
);
5200 /* Move to the end those items that should be at the end. */
5202 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5205 int end
= menu_bar_items_index
;
5207 for (i
= 0; i
< end
; i
+= 4)
5208 if (EQ (XCONS (tail
)->car
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
5210 Lisp_Object tem0
, tem1
, tem2
, tem3
;
5211 /* Move the item at index I to the end,
5212 shifting all the others forward. */
5213 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
5214 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
5215 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
5216 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
5218 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
5219 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
5220 (end
- i
- 4) * sizeof (Lisp_Object
));
5221 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
5222 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
5223 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
5224 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
5229 /* Add nil, nil, nil, nil at the end. */
5230 i
= menu_bar_items_index
;
5231 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
5234 int newsize
= 2 * i
;
5235 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
5236 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
5237 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
5238 menu_bar_items_vector
= tem
;
5240 /* Add this item. */
5241 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
5242 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
5243 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
5244 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
5245 menu_bar_items_index
= i
;
5247 Vinhibit_quit
= oquit
;
5249 return menu_bar_items_vector
;
5252 /* Scan one map KEYMAP, accumulating any menu items it defines
5253 in menu_bar_items_vector. */
5256 menu_bar_one_keymap (keymap
)
5259 Lisp_Object tail
, item
, key
, binding
, item_string
, table
;
5261 /* Loop over all keymap entries that have menu strings. */
5262 for (tail
= keymap
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
5264 item
= XCONS (tail
)->car
;
5267 key
= XCONS (item
)->car
;
5268 binding
= XCONS (item
)->cdr
;
5269 if (CONSP (binding
))
5271 item_string
= XCONS (binding
)->car
;
5272 if (STRINGP (item_string
))
5273 menu_bar_item (key
, item_string
, Fcdr (binding
));
5275 else if (EQ (binding
, Qundefined
))
5276 menu_bar_item (key
, Qnil
, binding
);
5278 else if (VECTORP (item
))
5280 /* Loop over the char values represented in the vector. */
5281 int len
= XVECTOR (item
)->size
;
5283 for (c
= 0; c
< len
; c
++)
5285 Lisp_Object character
;
5286 XSETFASTINT (character
, c
);
5287 binding
= XVECTOR (item
)->contents
[c
];
5288 if (CONSP (binding
))
5290 item_string
= XCONS (binding
)->car
;
5291 if (STRINGP (item_string
))
5292 menu_bar_item (key
, item_string
, Fcdr (binding
));
5294 else if (EQ (binding
, Qundefined
))
5295 menu_bar_item (key
, Qnil
, binding
);
5301 /* This is used as the handler when calling internal_condition_case_1. */
5304 menu_bar_item_1 (arg
)
5310 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
5311 If there's already an item for KEY, add this DEF to it. */
5314 menu_bar_item (key
, item_string
, def
)
5315 Lisp_Object key
, item_string
, def
;
5318 Lisp_Object enabled
;
5321 /* Skip menu-bar equiv keys data. */
5322 if (CONSP (def
) && CONSP (XCONS (def
)->car
))
5323 def
= XCONS (def
)->cdr
;
5325 if (EQ (def
, Qundefined
))
5327 /* If a map has an explicit `undefined' as definition,
5328 discard any previously made menu bar item. */
5330 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
5331 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
5333 if (menu_bar_items_index
> i
+ 4)
5334 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
5335 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
5336 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
5337 menu_bar_items_index
-= 4;
5341 /* If there's no definition for this key yet,
5342 just ignore `undefined'. */
5346 /* See if this entry is enabled. */
5351 /* No property, or nil, means enable.
5352 Otherwise, enable if value is not nil. */
5353 tem
= Fget (def
, Qmenu_enable
);
5355 /* (condition-case nil (eval tem)
5357 enabled
= internal_condition_case_1 (Feval
, tem
, Qerror
,
5361 /* Ignore this item if it's not enabled. */
5365 /* Find any existing item for this KEY. */
5366 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
5367 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
5370 /* If we did not find this KEY, add it at the end. */
5371 if (i
== menu_bar_items_index
)
5373 /* If vector is too small, get a bigger one. */
5374 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
5377 int newsize
= 2 * i
;
5378 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
5379 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
5380 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
5381 menu_bar_items_vector
= tem
;
5383 /* Add this item. */
5384 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
5385 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = item_string
;
5386 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (def
, Qnil
);
5387 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
5388 menu_bar_items_index
= i
;
5390 /* We did find an item for this KEY. Add DEF to its list of maps. */
5394 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
5395 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = Fcons (def
, old
);
5399 /* Read a character using menus based on maps in the array MAPS.
5400 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
5401 Return t if we displayed a menu but the user rejected it.
5403 PREV_EVENT is the previous input event, or nil if we are reading
5404 the first event of a key sequence.
5406 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
5407 if we used a mouse menu to read the input, or zero otherwise. If
5408 USED_MOUSE_MENU is null, we don't dereference it.
5410 The prompting is done based on the prompt-string of the map
5411 and the strings associated with various map elements.
5413 This can be done with X menus or with menus put in the minibuf.
5414 These are done in different ways, depending on how the input will be read.
5415 Menus using X are done after auto-saving in read-char, getting the input
5416 event from Fx_popup_menu; menus using the minibuf use read_char recursively
5417 and do auto-saving in the inner call of read_char. */
5420 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
5423 Lisp_Object prev_event
;
5424 int *used_mouse_menu
;
5427 register Lisp_Object name
;
5428 Lisp_Object rest
, vector
;
5430 if (used_mouse_menu
)
5431 *used_mouse_menu
= 0;
5433 /* Use local over global Menu maps */
5435 if (! menu_prompting
)
5438 /* Optionally disregard all but the global map. */
5439 if (inhibit_local_menu_bar_menus
)
5441 maps
+= (nmaps
- 1);
5445 /* Get the menu name from the first map that has one (a prompt string). */
5446 for (mapno
= 0; mapno
< nmaps
; mapno
++)
5448 name
= map_prompt (maps
[mapno
]);
5453 /* If we don't have any menus, just read a character normally. */
5458 /* If we got to this point via a mouse click,
5459 use a real menu for mouse selection. */
5460 if (EVENT_HAS_PARAMETERS (prev_event
)
5461 && !EQ (XCONS (prev_event
)->car
, Qmenu_bar
))
5463 /* Display the menu and get the selection. */
5464 Lisp_Object
*realmaps
5465 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
5469 /* Use the maps that are not nil. */
5470 for (mapno
= 0; mapno
< nmaps
; mapno
++)
5471 if (!NILP (maps
[mapno
]))
5472 realmaps
[nmaps1
++] = maps
[mapno
];
5474 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
5479 record_menu_key (XCONS (value
)->car
);
5481 /* If we got multiple events, unread all but
5483 There is no way to prevent those unread events
5484 from showing up later in last_nonmenu_event.
5485 So turn symbol and integer events into lists,
5486 to indicate that they came from a mouse menu,
5487 so that when present in last_nonmenu_event
5488 they won't confuse things. */
5489 for (tem
= XCONS (value
)->cdr
; !NILP (tem
);
5490 tem
= XCONS (tem
)->cdr
)
5492 record_menu_key (XCONS (tem
)->car
);
5493 if (SYMBOLP (XCONS (tem
)->car
)
5494 || INTEGERP (XCONS (tem
)->car
))
5496 = Fcons (XCONS (tem
)->car
, Qnil
);
5499 /* If we got more than one event, put all but the first
5500 onto this list to be read later.
5501 Return just the first event now. */
5502 Vunread_command_events
5503 = nconc2 (XCONS (value
)->cdr
, Vunread_command_events
);
5504 value
= XCONS (value
)->car
;
5506 else if (NILP (value
))
5508 if (used_mouse_menu
)
5509 *used_mouse_menu
= 1;
5512 #endif /* HAVE_MENUS */
5516 /* Buffer in use so far for the minibuf prompts for menu keymaps.
5517 We make this bigger when necessary, and never free it. */
5518 static char *read_char_minibuf_menu_text
;
5519 /* Size of that buffer. */
5520 static int read_char_minibuf_menu_width
;
5523 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
5529 register Lisp_Object name
;
5531 int width
= FRAME_WIDTH (selected_frame
) - 4;
5534 Lisp_Object rest
, vector
;
5537 if (! menu_prompting
)
5540 /* Make sure we have a big enough buffer for the menu text. */
5541 if (read_char_minibuf_menu_text
== 0)
5543 read_char_minibuf_menu_width
= width
+ 4;
5544 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
5546 else if (width
+ 4 > read_char_minibuf_menu_width
)
5548 read_char_minibuf_menu_width
= width
+ 4;
5549 read_char_minibuf_menu_text
5550 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
5552 menu
= read_char_minibuf_menu_text
;
5554 /* Get the menu name from the first map that has one (a prompt string). */
5555 for (mapno
= 0; mapno
< nmaps
; mapno
++)
5557 name
= map_prompt (maps
[mapno
]);
5562 /* If we don't have any menus, just read a character normally. */
5566 /* Prompt string always starts with map's prompt, and a space. */
5567 strcpy (menu
, XSTRING (name
)->data
);
5568 nlength
= XSTRING (name
)->size
;
5569 menu
[nlength
++] = ':';
5570 menu
[nlength
++] = ' ';
5573 /* Start prompting at start of first map. */
5577 /* Present the documented bindings, a line at a time. */
5584 Lisp_Object orig_defn_macro
;
5586 /* Loop over elements of map. */
5591 /* If reached end of map, start at beginning of next map. */
5595 /* At end of last map, wrap around to first map if just starting,
5596 or end this line if already have something on it. */
5600 if (notfirst
|| nobindings
) break;
5605 /* Look at the next element of the map. */
5607 elt
= XVECTOR (vector
)->contents
[idx
];
5609 elt
= Fcar_safe (rest
);
5611 if (idx
< 0 && VECTORP (elt
))
5613 /* If we found a dense table in the keymap,
5614 advanced past it, but start scanning its contents. */
5615 rest
= Fcdr_safe (rest
);
5621 /* An ordinary element. */
5626 s
= Fcar_safe (Fcdr_safe (elt
)); /* alist */
5627 event
= Fcar_safe (elt
);
5631 s
= Fcar_safe (elt
); /* vector */
5632 XSETINT (event
, idx
);
5635 /* Ignore the element if it has no prompt string. */
5636 if (STRINGP (s
) && INTEGERP (event
))
5638 /* 1 if the char to type matches the string. */
5640 Lisp_Object upcased_event
, downcased_event
;
5643 upcased_event
= Fupcase (event
);
5644 downcased_event
= Fdowncase (event
);
5645 char_matches
= (XINT (upcased_event
) == XSTRING (s
)->data
[0]
5646 || XINT (downcased_event
) == XSTRING (s
)->data
[0]);
5648 desc
= Fsingle_key_description (event
);
5650 /* If we have room for the prompt string, add it to this line.
5651 If this is the first on the line, always add it. */
5652 if ((XSTRING (s
)->size
+ i
+ 2
5653 + (char_matches
? 0 : XSTRING (desc
)->size
+ 3))
5659 /* Punctuate between strings. */
5662 strcpy (menu
+ i
, ", ");
5668 /* If the char to type doesn't match the string's
5669 first char, explicitly show what char to type. */
5672 /* Add as much of string as fits. */
5673 thiswidth
= XSTRING (desc
)->size
;
5674 if (thiswidth
+ i
> width
)
5675 thiswidth
= width
- i
;
5676 bcopy (XSTRING (desc
)->data
, menu
+ i
, thiswidth
);
5678 strcpy (menu
+ i
, " = ");
5682 /* Add as much of string as fits. */
5683 thiswidth
= XSTRING (s
)->size
;
5684 if (thiswidth
+ i
> width
)
5685 thiswidth
= width
- i
;
5686 bcopy (XSTRING (s
)->data
, menu
+ i
, thiswidth
);
5692 /* If this element does not fit, end the line now,
5693 and save the element for the next line. */
5694 strcpy (menu
+ i
, "...");
5699 /* Move past this element. */
5700 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
5701 /* Handle reaching end of dense table. */
5706 rest
= Fcdr_safe (rest
);
5710 /* Prompt with that and read response. */
5713 /* Make believe its not a keyboard macro in case the help char
5714 is pressed. Help characters are not recorded because menu prompting
5715 is not used on replay.
5717 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
5718 current_kboard
->defining_kbd_macro
= Qnil
;
5720 obj
= read_char (commandflag
, 0, 0, Qnil
, 0);
5721 while (BUFFERP (obj
));
5722 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
5724 if (!INTEGERP (obj
))
5729 if (! EQ (obj
, menu_prompt_more_char
)
5730 && (!INTEGERP (menu_prompt_more_char
)
5731 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
5733 if (!NILP (current_kboard
->defining_kbd_macro
))
5734 store_kbd_macro_char (obj
);
5737 /* Help char - go round again */
5741 /* Reading key sequences. */
5743 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
5744 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
5745 keymap, or nil otherwise. Return the index of the first keymap in
5746 which KEY has any binding, or NMAPS if no map has a binding.
5748 If KEY is a meta ASCII character, treat it like meta-prefix-char
5749 followed by the corresponding non-meta character. Keymaps in
5750 CURRENT with non-prefix bindings for meta-prefix-char become nil in
5753 If KEY has no bindings in any of the CURRENT maps, NEXT is left
5756 NEXT may be the same array as CURRENT. */
5759 follow_key (key
, nmaps
, current
, defs
, next
)
5761 Lisp_Object
*current
, *defs
, *next
;
5764 int i
, first_binding
;
5767 /* If KEY is a meta ASCII character, treat it like meta-prefix-char
5768 followed by the corresponding non-meta character.
5769 Put the results into DEFS, since we are going to alter that anyway.
5770 Do not alter CURRENT or NEXT. */
5771 if (INTEGERP (key
) && (XINT (key
) & CHAR_META
))
5773 for (i
= 0; i
< nmaps
; i
++)
5774 if (! NILP (current
[i
]))
5777 def
= get_keyelt (access_keymap (current
[i
],
5778 meta_prefix_char
, 1, 0), 0);
5780 /* Note that since we pass the resulting bindings through
5781 get_keymap_1, non-prefix bindings for meta-prefix-char
5783 defs
[i
] = get_keymap_1 (def
, 0, 1);
5789 XSETINT (key
, XFASTINT (key
) & ~CHAR_META
);
5792 first_binding
= nmaps
;
5793 for (i
= nmaps
- 1; i
>= 0; i
--)
5795 if (! NILP (current
[i
]))
5803 defs
[i
] = get_keyelt (access_keymap (map
, key
, 1, 0), 0);
5804 if (! NILP (defs
[i
]))
5811 /* Given the set of bindings we've found, produce the next set of maps. */
5812 if (first_binding
< nmaps
)
5813 for (i
= 0; i
< nmaps
; i
++)
5814 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap_1 (defs
[i
], 0, 1);
5816 return first_binding
;
5819 /* Read a sequence of keys that ends with a non prefix character,
5820 storing it in KEYBUF, a buffer of size BUFSIZE.
5822 Return the length of the key sequence stored.
5823 Return -1 if the user rejected a command menu.
5825 Echo starting immediately unless `prompt' is 0.
5827 Where a key sequence ends depends on the currently active keymaps.
5828 These include any minor mode keymaps active in the current buffer,
5829 the current buffer's local map, and the global map.
5831 If a key sequence has no other bindings, we check Vfunction_key_map
5832 to see if some trailing subsequence might be the beginning of a
5833 function key's sequence. If so, we try to read the whole function
5834 key, and substitute its symbolic name into the key sequence.
5836 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
5837 `double-' events into similar click events, if that would make them
5838 bound. We try to turn `triple-' events first into `double-' events,
5841 If we get a mouse click in a mode line, vertical divider, or other
5842 non-text area, we treat the click as if it were prefixed by the
5843 symbol denoting that area - `mode-line', `vertical-line', or
5846 If the sequence starts with a mouse click, we read the key sequence
5847 with respect to the buffer clicked on, not the current buffer.
5849 If the user switches frames in the midst of a key sequence, we put
5850 off the switch-frame event until later; the next call to
5851 read_char will return it.
5853 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
5854 from the selected window's buffer. */
5857 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
5858 can_return_switch_frame
, fix_current_buffer
)
5859 Lisp_Object
*keybuf
;
5862 int dont_downcase_last
;
5863 int can_return_switch_frame
;
5864 int fix_current_buffer
;
5866 int count
= specpdl_ptr
- specpdl
;
5868 /* How many keys there are in the current key sequence. */
5871 /* The length of the echo buffer when we started reading, and
5872 the length of this_command_keys when we started reading. */
5876 /* The number of keymaps we're scanning right now, and the number of
5877 keymaps we have allocated space for. */
5879 int nmaps_allocated
= 0;
5881 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
5882 the current keymaps. */
5885 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
5886 in the current keymaps, or nil where it is not a prefix. */
5887 Lisp_Object
*submaps
;
5889 /* The local map to start out with at start of key sequence. */
5890 Lisp_Object orig_local_map
;
5892 /* 1 if we have already considered switching to the local-map property
5893 of the place where a mouse click occurred. */
5894 int localized_local_map
= 0;
5896 /* The index in defs[] of the first keymap that has a binding for
5897 this key sequence. In other words, the lowest i such that
5898 defs[i] is non-nil. */
5901 /* If t < mock_input, then KEYBUF[t] should be read as the next
5904 We use this to recover after recognizing a function key. Once we
5905 realize that a suffix of the current key sequence is actually a
5906 function key's escape sequence, we replace the suffix with the
5907 function key's binding from Vfunction_key_map. Now keybuf
5908 contains a new and different key sequence, so the echo area,
5909 this_command_keys, and the submaps and defs arrays are wrong. In
5910 this situation, we set mock_input to t, set t to 0, and jump to
5911 restart_sequence; the loop will read keys from keybuf up until
5912 mock_input, thus rebuilding the state; and then it will resume
5913 reading characters from the keyboard. */
5916 /* If the sequence is unbound in submaps[], then
5917 keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
5918 and fkey_map is its binding.
5920 These might be > t, indicating that all function key scanning
5921 should hold off until t reaches them. We do this when we've just
5922 recognized a function key, to avoid searching for the function
5923 key's again in Vfunction_key_map. */
5924 int fkey_start
= 0, fkey_end
= 0;
5925 Lisp_Object fkey_map
;
5927 /* Likewise, for key_translation_map. */
5928 int keytran_start
= 0, keytran_end
= 0;
5929 Lisp_Object keytran_map
;
5931 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
5932 we put it off for later. While we're reading, we keep the event here. */
5933 Lisp_Object delayed_switch_frame
;
5935 /* See the comment below... */
5936 #if defined (GOBBLE_FIRST_EVENT)
5937 Lisp_Object first_event
;
5940 Lisp_Object original_uppercase
;
5941 int original_uppercase_position
= -1;
5943 /* Gets around Microsoft compiler limitations. */
5946 struct buffer
*starting_buffer
;
5948 /* Nonzero if we seem to have got the beginning of a binding
5949 in function_key_map. */
5950 int function_key_possible
= 0;
5951 int key_translation_possible
= 0;
5953 /* Save the status of key translation before each step,
5954 so that we can restore this after downcasing. */
5955 Lisp_Object prev_fkey_map
;
5956 int prev_fkey_start
;
5959 Lisp_Object prev_keytran_map
;
5960 int prev_keytran_start
;
5961 int prev_keytran_end
;
5965 last_nonmenu_event
= Qnil
;
5967 delayed_switch_frame
= Qnil
;
5968 fkey_map
= Vfunction_key_map
;
5969 keytran_map
= Vkey_translation_map
;
5971 /* If there is no function-key-map, turn off function key scanning. */
5972 if (NILP (Fkeymapp (Vfunction_key_map
)))
5973 fkey_start
= fkey_end
= bufsize
+ 1;
5975 /* If there is no key-translation-map, turn off scanning. */
5976 if (NILP (Fkeymapp (Vkey_translation_map
)))
5977 keytran_start
= keytran_end
= bufsize
+ 1;
5982 echo_prompt (XSTRING (prompt
)->data
);
5983 else if (cursor_in_echo_area
&& echo_keystrokes
)
5984 /* This doesn't put in a dash if the echo buffer is empty, so
5985 you don't always see a dash hanging out in the minibuffer. */
5989 /* Record the initial state of the echo area and this_command_keys;
5990 we will need to restore them if we replay a key sequence. */
5992 echo_start
= echo_length ();
5993 keys_start
= this_command_key_count
;
5994 this_single_command_key_start
= keys_start
;
5996 #if defined (GOBBLE_FIRST_EVENT)
5997 /* This doesn't quite work, because some of the things that read_char
5998 does cannot safely be bypassed. It seems too risky to try to make
6001 /* Read the first char of the sequence specially, before setting
6002 up any keymaps, in case a filter runs and switches buffers on us. */
6003 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
6005 #endif /* GOBBLE_FIRST_EVENT */
6007 orig_local_map
= get_local_map (PT
, current_buffer
);
6009 /* We jump here when the key sequence has been thoroughly changed, and
6010 we need to rescan it starting from the beginning. When we jump here,
6011 keybuf[0..mock_input] holds the sequence we should reread. */
6014 starting_buffer
= current_buffer
;
6015 function_key_possible
= 0;
6016 key_translation_possible
= 0;
6018 /* Build our list of keymaps.
6019 If we recognize a function key and replace its escape sequence in
6020 keybuf with its symbol, or if the sequence starts with a mouse
6021 click and we need to switch buffers, we jump back here to rebuild
6022 the initial keymaps from the current buffer. */
6026 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
6027 || !NILP (Voverriding_local_map
))
6029 if (3 > nmaps_allocated
)
6031 submaps
= (Lisp_Object
*) alloca (3 * sizeof (submaps
[0]));
6032 defs
= (Lisp_Object
*) alloca (3 * sizeof (defs
[0]));
6033 nmaps_allocated
= 3;
6036 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
6037 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
6038 if (!NILP (Voverriding_local_map
))
6039 submaps
[nmaps
++] = Voverriding_local_map
;
6043 nmaps
= current_minor_maps (0, &maps
);
6044 if (nmaps
+ 2 > nmaps_allocated
)
6046 submaps
= (Lisp_Object
*) alloca ((nmaps
+2) * sizeof (submaps
[0]));
6047 defs
= (Lisp_Object
*) alloca ((nmaps
+2) * sizeof (defs
[0]));
6048 nmaps_allocated
= nmaps
+ 2;
6050 bcopy (maps
, submaps
, nmaps
* sizeof (submaps
[0]));
6051 #ifdef USE_TEXT_PROPERTIES
6052 submaps
[nmaps
++] = orig_local_map
;
6054 submaps
[nmaps
++] = current_buffer
->keymap
;
6057 submaps
[nmaps
++] = current_global_map
;
6060 /* Find an accurate initial value for first_binding. */
6061 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
6062 if (! NILP (submaps
[first_binding
]))
6065 /* Start from the beginning in keybuf. */
6068 /* These are no-ops the first time through, but if we restart, they
6069 revert the echo area and this_command_keys to their original state. */
6070 this_command_key_count
= keys_start
;
6071 if (INTERACTIVE
&& t
< mock_input
)
6072 echo_truncate (echo_start
);
6074 /* If the best binding for the current key sequence is a keymap, or
6075 we may be looking at a function key's escape sequence, keep on
6077 while ((first_binding
< nmaps
&& ! NILP (submaps
[first_binding
]))
6078 || (first_binding
>= nmaps
6080 /* mock input is never part of a function key's sequence. */
6081 && mock_input
<= fkey_start
)
6082 || (first_binding
>= nmaps
6083 && keytran_start
< t
&& key_translation_possible
)
6084 /* Don't return in the middle of a possible function key sequence,
6085 if the only bindings we found were via case conversion.
6086 Thus, if ESC O a has a function-key-map translation
6087 and ESC o has a binding, don't return after ESC O,
6088 so that we can translate ESC O plus the next character. */
6092 int used_mouse_menu
= 0;
6094 /* Where the last real key started. If we need to throw away a
6095 key that has expanded into more than one element of keybuf
6096 (say, a mouse click on the mode line which is being treated
6097 as [mode-line (mouse-...)], then we backtrack to this point
6099 int last_real_key_start
;
6101 /* These variables are analogous to echo_start and keys_start;
6102 while those allow us to restart the entire key sequence,
6103 echo_local_start and keys_local_start allow us to throw away
6105 int echo_local_start
, keys_local_start
, local_first_binding
;
6108 error ("Key sequence too long");
6111 echo_local_start
= echo_length ();
6112 keys_local_start
= this_command_key_count
;
6113 local_first_binding
= first_binding
;
6116 /* These are no-ops, unless we throw away a keystroke below and
6117 jumped back up to replay_key; in that case, these restore the
6118 variables to their original state, allowing us to replay the
6120 if (INTERACTIVE
&& t
< mock_input
)
6121 echo_truncate (echo_local_start
);
6122 this_command_key_count
= keys_local_start
;
6123 first_binding
= local_first_binding
;
6125 /* By default, assume each event is "real". */
6126 last_real_key_start
= t
;
6128 /* Does mock_input indicate that we are re-reading a key sequence? */
6132 add_command_key (key
);
6133 if (echo_keystrokes
)
6137 /* If not, we should actually read a character. */
6140 struct buffer
*buf
= current_buffer
;
6144 KBOARD
*interrupted_kboard
= current_kboard
;
6145 struct frame
*interrupted_frame
= selected_frame
;
6146 if (setjmp (wrong_kboard_jmpbuf
))
6148 if (!NILP (delayed_switch_frame
))
6150 interrupted_kboard
->kbd_queue
6151 = Fcons (delayed_switch_frame
,
6152 interrupted_kboard
->kbd_queue
);
6153 delayed_switch_frame
= Qnil
;
6156 interrupted_kboard
->kbd_queue
6157 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
6159 /* If the side queue is non-empty, ensure it begins with a
6160 switch-frame, so we'll replay it in the right context. */
6161 if (CONSP (interrupted_kboard
->kbd_queue
)
6162 && (key
= XCONS (interrupted_kboard
->kbd_queue
)->car
,
6163 !(EVENT_HAS_PARAMETERS (key
)
6164 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
6168 XSETFRAME (frame
, interrupted_frame
);
6169 interrupted_kboard
->kbd_queue
6170 = Fcons (make_lispy_switch_frame (frame
),
6171 interrupted_kboard
->kbd_queue
);
6174 orig_local_map
= get_local_map (PT
, current_buffer
);
6175 goto replay_sequence
;
6178 key
= read_char (NILP (prompt
), nmaps
, submaps
, last_nonmenu_event
,
6182 /* read_char returns t when it shows a menu and the user rejects it.
6187 /* read_char returns -1 at the end of a macro.
6188 Emacs 18 handles this by returning immediately with a
6189 zero, so that's what we'll do. */
6190 if (INTEGERP (key
) && XINT (key
) == -1)
6193 /* The Microsoft C compiler can't handle the goto that
6199 /* If the current buffer has been changed from under us, the
6200 keymap may have changed, so replay the sequence. */
6204 /* Reset the current buffer from the selected window
6205 in case something changed the former and not the latter.
6206 This is to be more consistent with the behavior
6207 of the command_loop_1. */
6208 if (fix_current_buffer
)
6209 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
6210 Fset_buffer (XWINDOW (selected_window
)->buffer
);
6212 orig_local_map
= get_local_map (PT
, current_buffer
);
6213 goto replay_sequence
;
6216 /* If we have a quit that was typed in another frame, and
6217 quit_throw_to_read_char switched buffers,
6218 replay to get the right keymap. */
6219 if (XINT (key
) == quit_char
&& current_buffer
!= starting_buffer
)
6224 orig_local_map
= get_local_map (PT
, current_buffer
);
6225 goto replay_sequence
;
6231 /* Clicks in non-text areas get prefixed by the symbol
6232 in their CHAR-ADDRESS field. For example, a click on
6233 the mode line is prefixed by the symbol `mode-line'.
6235 Furthermore, key sequences beginning with mouse clicks
6236 are read using the keymaps of the buffer clicked on, not
6237 the current buffer. So we may have to switch the buffer
6240 When we turn one event into two events, we must make sure
6241 that neither of the two looks like the original--so that,
6242 if we replay the events, they won't be expanded again.
6243 If not for this, such reexpansion could happen either here
6244 or when user programs play with this-command-keys. */
6245 if (EVENT_HAS_PARAMETERS (key
))
6249 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
6250 if (EQ (kind
, Qmouse_click
))
6252 Lisp_Object window
, posn
;
6254 window
= POSN_WINDOW (EVENT_START (key
));
6255 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
6258 /* We're looking at the second event of a
6259 sequence which we expanded before. Set
6260 last_real_key_start appropriately. */
6262 last_real_key_start
= t
- 1;
6265 /* Key sequences beginning with mouse clicks are
6266 read using the keymaps in the buffer clicked on,
6267 not the current buffer. If we're at the
6268 beginning of a key sequence, switch buffers. */
6269 if (last_real_key_start
== 0
6271 && BUFFERP (XWINDOW (window
)->buffer
)
6272 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
6277 /* Arrange to go back to the original buffer once we're
6278 done reading the key sequence. Note that we can't
6279 use save_excursion_{save,restore} here, because they
6280 save point as well as the current buffer; we don't
6281 want to save point, because redisplay may change it,
6282 to accommodate a Fset_window_start or something. We
6283 don't want to do this at the top of the function,
6284 because we may get input from a subprocess which
6285 wants to change the selected window and stuff (say,
6287 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
6289 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
6290 orig_local_map
= get_local_map (PT
, current_buffer
);
6291 goto replay_sequence
;
6293 /* For a mouse click, get the local text-property keymap
6294 of the place clicked on, rather than point. */
6295 if (last_real_key_start
== 0 && CONSP (XCONS (key
)->cdr
)
6296 && ! localized_local_map
)
6298 Lisp_Object map_here
, start
, pos
;
6300 localized_local_map
= 1;
6301 start
= EVENT_START (key
);
6302 if (CONSP (start
) && CONSP (XCONS (start
)->cdr
))
6304 pos
= POSN_BUFFER_POSN (start
);
6306 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
6308 map_here
= get_local_map (XINT (pos
), current_buffer
);
6309 if (!EQ (map_here
, orig_local_map
))
6311 orig_local_map
= map_here
;
6315 goto replay_sequence
;
6321 /* Expand mode-line and scroll-bar events into two events:
6322 use posn as a fake prefix key. */
6325 if (t
+ 1 >= bufsize
)
6326 error ("Key sequence too long");
6331 /* Zap the position in key, so we know that we've
6332 expanded it, and don't try to do so again. */
6333 POSN_BUFFER_POSN (EVENT_START (key
))
6334 = Fcons (posn
, Qnil
);
6338 else if (EQ (kind
, Qswitch_frame
))
6340 /* If we're at the beginning of a key sequence, and the caller
6341 says it's okay, go ahead and return this event. If we're
6342 in the midst of a key sequence, delay it until the end. */
6343 if (t
> 0 || !can_return_switch_frame
)
6345 delayed_switch_frame
= key
;
6349 else if (CONSP (XCONS (key
)->cdr
)
6350 && CONSP (EVENT_START (key
))
6351 && CONSP (XCONS (EVENT_START (key
))->cdr
))
6355 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
6356 /* Handle menu-bar events:
6357 insert the dummy prefix event `menu-bar'. */
6358 if (EQ (posn
, Qmenu_bar
))
6360 if (t
+ 1 >= bufsize
)
6361 error ("Key sequence too long");
6365 /* Zap the position in key, so we know that we've
6366 expanded it, and don't try to do so again. */
6367 POSN_BUFFER_POSN (EVENT_START (key
))
6368 = Fcons (posn
, Qnil
);
6371 goto replay_sequence
;
6373 else if (CONSP (posn
))
6375 /* We're looking at the second event of a
6376 sequence which we expanded before. Set
6377 last_real_key_start appropriately. */
6378 if (last_real_key_start
== t
&& t
> 0)
6379 last_real_key_start
= t
- 1;
6384 /* We have finally decided that KEY is something we might want
6386 first_binding
= (follow_key (key
,
6387 nmaps
- first_binding
,
6388 submaps
+ first_binding
,
6389 defs
+ first_binding
,
6390 submaps
+ first_binding
)
6393 /* If KEY wasn't bound, we'll try some fallbacks. */
6394 if (first_binding
>= nmaps
)
6398 head
= EVENT_HEAD (key
);
6399 if (help_char_p (head
) && t
> 0)
6401 read_key_sequence_cmd
= Vprefix_help_command
;
6403 last_nonmenu_event
= key
;
6404 /* The Microsoft C compiler can't handle the goto that
6412 Lisp_Object breakdown
;
6415 breakdown
= parse_modifiers (head
);
6416 modifiers
= XINT (XCONS (XCONS (breakdown
)->cdr
)->car
);
6417 /* Attempt to reduce an unbound mouse event to a simpler
6418 event that is bound:
6419 Drags reduce to clicks.
6420 Double-clicks reduce to clicks.
6421 Triple-clicks reduce to double-clicks, then to clicks.
6422 Down-clicks are eliminated.
6423 Double-downs reduce to downs, then are eliminated.
6424 Triple-downs reduce to double-downs, then to downs,
6425 then are eliminated. */
6426 if (modifiers
& (down_modifier
| drag_modifier
6427 | double_modifier
| triple_modifier
))
6429 while (modifiers
& (down_modifier
| drag_modifier
6430 | double_modifier
| triple_modifier
))
6432 Lisp_Object new_head
, new_click
;
6433 if (modifiers
& triple_modifier
)
6434 modifiers
^= (double_modifier
| triple_modifier
);
6435 else if (modifiers
& double_modifier
)
6436 modifiers
&= ~double_modifier
;
6437 else if (modifiers
& drag_modifier
)
6438 modifiers
&= ~drag_modifier
;
6441 /* Dispose of this `down' event by simply jumping
6442 back to replay_key, to get another event.
6444 Note that if this event came from mock input,
6445 then just jumping back to replay_key will just
6446 hand it to us again. So we have to wipe out any
6449 We could delete keybuf[t] and shift everything
6450 after that to the left by one spot, but we'd also
6451 have to fix up any variable that points into
6452 keybuf, and shifting isn't really necessary
6455 Adding prefixes for non-textual mouse clicks
6456 creates two characters of mock input, and both
6457 must be thrown away. If we're only looking at
6458 the prefix now, we can just jump back to
6459 replay_key. On the other hand, if we've already
6460 processed the prefix, and now the actual click
6461 itself is giving us trouble, then we've lost the
6462 state of the keymaps we want to backtrack to, and
6463 we need to replay the whole sequence to rebuild
6466 Beyond that, only function key expansion could
6467 create more than two keys, but that should never
6468 generate mouse events, so it's okay to zero
6469 mock_input in that case too.
6471 Isn't this just the most wonderful code ever? */
6472 if (t
== last_real_key_start
)
6479 mock_input
= last_real_key_start
;
6480 goto replay_sequence
;
6485 = apply_modifiers (modifiers
, XCONS (breakdown
)->car
);
6487 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
6489 /* Look for a binding for this new key. follow_key
6490 promises that it didn't munge submaps the
6491 last time we called it, since key was unbound. */
6493 = (follow_key (new_click
,
6494 nmaps
- local_first_binding
,
6495 submaps
+ local_first_binding
,
6496 defs
+ local_first_binding
,
6497 submaps
+ local_first_binding
)
6498 + local_first_binding
);
6500 /* If that click is bound, go for it. */
6501 if (first_binding
< nmaps
)
6506 /* Otherwise, we'll leave key set to the drag event. */
6513 /* Normally, last_nonmenu_event gets the previous key we read.
6514 But when a mouse popup menu is being used,
6515 we don't update last_nonmenu_event; it continues to hold the mouse
6516 event that preceded the first level of menu. */
6517 if (!used_mouse_menu
)
6518 last_nonmenu_event
= key
;
6520 /* Record what part of this_command_keys is the current key sequence. */
6521 this_single_command_key_start
= this_command_key_count
- t
;
6523 prev_fkey_map
= fkey_map
;
6524 prev_fkey_start
= fkey_start
;
6525 prev_fkey_end
= fkey_end
;
6527 prev_keytran_map
= keytran_map
;
6528 prev_keytran_start
= keytran_start
;
6529 prev_keytran_end
= keytran_end
;
6531 /* If the sequence is unbound, see if we can hang a function key
6532 off the end of it. We only want to scan real keyboard input
6533 for function key sequences, so if mock_input says that we're
6534 re-reading old events, don't examine it. */
6535 if (first_binding
>= nmaps
6538 Lisp_Object fkey_next
;
6540 /* Continue scan from fkey_end until we find a bound suffix.
6541 If we fail, increment fkey_start
6542 and start fkey_end from there. */
6543 while (fkey_end
< t
)
6547 key
= keybuf
[fkey_end
++];
6548 /* Look up meta-characters by prefixing them
6549 with meta_prefix_char. I hate this. */
6550 if (INTEGERP (key
) && XINT (key
) & meta_modifier
)
6555 (access_keymap (fkey_map
, meta_prefix_char
, 1, 0), 0),
6557 XSETFASTINT (key
, XFASTINT (key
) & ~meta_modifier
);
6560 fkey_next
= fkey_map
;
6563 = get_keyelt (access_keymap (fkey_next
, key
, 1, 0), 0);
6565 #if 0 /* I didn't turn this on, because it might cause trouble
6566 for the mapping of return into C-m and tab into C-i. */
6567 /* Optionally don't map function keys into other things.
6568 This enables the user to redefine kp- keys easily. */
6569 if (SYMBOLP (key
) && !NILP (Vinhibit_function_key_mapping
))
6573 /* If the function key map gives a function, not an
6574 array, then call the function with no args and use
6575 its value instead. */
6576 if (SYMBOLP (fkey_next
) && ! NILP (Ffboundp (fkey_next
))
6579 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6583 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
6584 fkey_next
= call1 (fkey_next
, prompt
);
6586 /* If the function returned something invalid,
6587 barf--don't ignore it.
6588 (To ignore it safely, we would need to gcpro a bunch of
6589 other variables.) */
6590 if (! (VECTORP (fkey_next
) || STRINGP (fkey_next
)))
6591 error ("Function in key-translation-map returns invalid key sequence");
6594 function_key_possible
= ! NILP (fkey_next
);
6596 /* If keybuf[fkey_start..fkey_end] is bound in the
6597 function key map and it's a suffix of the current
6598 sequence (i.e. fkey_end == t), replace it with
6599 the binding and restart with fkey_start at the end. */
6600 if ((VECTORP (fkey_next
) || STRINGP (fkey_next
))
6603 int len
= XFASTINT (Flength (fkey_next
));
6605 t
= fkey_start
+ len
;
6607 error ("Key sequence too long");
6609 if (VECTORP (fkey_next
))
6610 bcopy (XVECTOR (fkey_next
)->contents
,
6611 keybuf
+ fkey_start
,
6612 (t
- fkey_start
) * sizeof (keybuf
[0]));
6613 else if (STRINGP (fkey_next
))
6617 for (i
= 0; i
< len
; i
++)
6618 XSETFASTINT (keybuf
[fkey_start
+ i
],
6619 XSTRING (fkey_next
)->data
[i
]);
6623 fkey_start
= fkey_end
= t
;
6624 fkey_map
= Vfunction_key_map
;
6626 /* Do pass the results through key-translation-map. */
6627 keytran_start
= keytran_end
= 0;
6628 keytran_map
= Vkey_translation_map
;
6630 goto replay_sequence
;
6633 fkey_map
= get_keymap_1 (fkey_next
, 0, 1);
6635 /* If we no longer have a bound suffix, try a new positions for
6637 if (NILP (fkey_map
))
6639 fkey_end
= ++fkey_start
;
6640 fkey_map
= Vfunction_key_map
;
6641 function_key_possible
= 0;
6646 /* Look for this sequence in key-translation-map. */
6648 Lisp_Object keytran_next
;
6650 /* Scan from keytran_end until we find a bound suffix. */
6651 while (keytran_end
< t
)
6655 key
= keybuf
[keytran_end
++];
6656 /* Look up meta-characters by prefixing them
6657 with meta_prefix_char. I hate this. */
6658 if (INTEGERP (key
) && XINT (key
) & meta_modifier
)
6663 (access_keymap (keytran_map
, meta_prefix_char
, 1, 0), 0),
6665 XSETFASTINT (key
, XFASTINT (key
) & ~meta_modifier
);
6668 keytran_next
= keytran_map
;
6671 = get_keyelt (access_keymap (keytran_next
, key
, 1, 0), 0);
6673 /* If the key translation map gives a function, not an
6674 array, then call the function with no args and use
6675 its value instead. */
6676 if (SYMBOLP (keytran_next
) && ! NILP (Ffboundp (keytran_next
))
6677 && keytran_end
== t
)
6679 struct gcpro gcpro1
, gcpro2
, gcpro3
;
6683 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
6684 keytran_next
= call1 (keytran_next
, prompt
);
6686 /* If the function returned something invalid,
6687 barf--don't ignore it.
6688 (To ignore it safely, we would need to gcpro a bunch of
6689 other variables.) */
6690 if (! (VECTORP (keytran_next
) || STRINGP (keytran_next
)))
6691 error ("Function in key-translation-map returns invalid key sequence");
6694 key_translation_possible
= ! NILP (keytran_next
);
6696 /* If keybuf[keytran_start..keytran_end] is bound in the
6697 key translation map and it's a suffix of the current
6698 sequence (i.e. keytran_end == t), replace it with
6699 the binding and restart with keytran_start at the end. */
6700 if ((VECTORP (keytran_next
) || STRINGP (keytran_next
))
6701 && keytran_end
== t
)
6703 int len
= XFASTINT (Flength (keytran_next
));
6705 t
= keytran_start
+ len
;
6707 error ("Key sequence too long");
6709 if (VECTORP (keytran_next
))
6710 bcopy (XVECTOR (keytran_next
)->contents
,
6711 keybuf
+ keytran_start
,
6712 (t
- keytran_start
) * sizeof (keybuf
[0]));
6713 else if (STRINGP (keytran_next
))
6717 for (i
= 0; i
< len
; i
++)
6718 XSETFASTINT (keybuf
[keytran_start
+ i
],
6719 XSTRING (keytran_next
)->data
[i
]);
6723 keytran_start
= keytran_end
= t
;
6724 keytran_map
= Vkey_translation_map
;
6726 /* Don't pass the results of key-translation-map
6727 through function-key-map. */
6728 fkey_start
= fkey_end
= t
;
6729 fkey_map
= Vkey_translation_map
;
6731 goto replay_sequence
;
6734 keytran_map
= get_keymap_1 (keytran_next
, 0, 1);
6736 /* If we no longer have a bound suffix, try a new positions for
6738 if (NILP (keytran_map
))
6740 keytran_end
= ++keytran_start
;
6741 keytran_map
= Vkey_translation_map
;
6742 key_translation_possible
= 0;
6747 /* If KEY is not defined in any of the keymaps,
6748 and cannot be part of a function key or translation,
6749 and is an upper case letter
6750 use the corresponding lower-case letter instead. */
6751 if (first_binding
== nmaps
&& ! function_key_possible
6752 && ! key_translation_possible
6754 && ((((XINT (key
) & 0x3ffff)
6755 < XSTRING (current_buffer
->downcase_table
)->size
)
6756 && UPPERCASEP (XINT (key
) & 0x3ffff))
6757 || (XINT (key
) & shift_modifier
)))
6759 Lisp_Object new_key
;
6761 original_uppercase
= key
;
6762 original_uppercase_position
= t
- 1;
6764 if (XINT (key
) & shift_modifier
)
6765 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
6767 XSETINT (new_key
, (DOWNCASE (XINT (key
) & 0x3ffff)
6768 | (XINT (key
) & ~0x3ffff)));
6770 /* We have to do this unconditionally, regardless of whether
6771 the lower-case char is defined in the keymaps, because they
6772 might get translated through function-key-map. */
6773 keybuf
[t
- 1] = new_key
;
6776 fkey_map
= prev_fkey_map
;
6777 fkey_start
= prev_fkey_start
;
6778 fkey_end
= prev_fkey_end
;
6780 keytran_map
= prev_keytran_map
;
6781 keytran_start
= prev_keytran_start
;
6782 keytran_end
= prev_keytran_end
;
6784 goto replay_sequence
;
6786 /* If KEY is not defined in any of the keymaps,
6787 and cannot be part of a function key or translation,
6788 and is a shifted function key,
6789 use the corresponding unshifted function key instead. */
6790 if (first_binding
== nmaps
&& ! function_key_possible
6791 && ! key_translation_possible
6794 Lisp_Object breakdown
;
6797 breakdown
= parse_modifiers (key
);
6798 modifiers
= XINT (XCONS (XCONS (breakdown
)->cdr
)->car
);
6799 if (modifiers
& shift_modifier
)
6801 Lisp_Object new_key
;
6803 original_uppercase
= key
;
6804 original_uppercase_position
= t
- 1;
6806 modifiers
&= ~shift_modifier
;
6807 new_key
= apply_modifiers (modifiers
,
6808 XCONS (breakdown
)->car
);
6810 keybuf
[t
- 1] = new_key
;
6813 fkey_map
= prev_fkey_map
;
6814 fkey_start
= prev_fkey_start
;
6815 fkey_end
= prev_fkey_end
;
6817 keytran_map
= prev_keytran_map
;
6818 keytran_start
= prev_keytran_start
;
6819 keytran_end
= prev_keytran_end
;
6821 goto replay_sequence
;
6827 read_key_sequence_cmd
= (first_binding
< nmaps
6828 ? defs
[first_binding
]
6831 unread_switch_frame
= delayed_switch_frame
;
6832 unbind_to (count
, Qnil
);
6834 /* Don't downcase the last character if the caller says don't.
6835 Don't downcase it if the result is undefined, either. */
6836 if ((dont_downcase_last
|| first_binding
>= nmaps
)
6837 && t
- 1 == original_uppercase_position
)
6838 keybuf
[t
- 1] = original_uppercase
;
6840 /* Occasionally we fabricate events, perhaps by expanding something
6841 according to function-key-map, or by adding a prefix symbol to a
6842 mouse click in the scroll bar or modeline. In this cases, return
6843 the entire generated key sequence, even if we hit an unbound
6844 prefix or a definition before the end. This means that you will
6845 be able to push back the event properly, and also means that
6846 read-key-sequence will always return a logical unit.
6849 for (; t
< mock_input
; t
++)
6851 if (echo_keystrokes
)
6852 echo_char (keybuf
[t
]);
6853 add_command_key (keybuf
[t
]);
6859 #if 0 /* This doc string is too long for some compilers.
6860 This commented-out definition serves for DOC. */
6861 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 4, 0,
6862 "Read a sequence of keystrokes and return as a string or vector.\n\
6863 The sequence is sufficient to specify a non-prefix command in the\n\
6864 current local and global maps.\n\
6866 First arg PROMPT is a prompt string. If nil, do not prompt specially.\n\
6867 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
6868 as a continuation of the previous key.\n\
6870 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not\n\
6871 convert the last event to lower case. (Normally any upper case event\n\
6872 is converted to lower case if the original event is undefined and the lower\n\
6873 case equivalent is defined.) A non-nil value is appropriate for reading\n\
6874 a key sequence to be defined.\n\
6876 A C-g typed while in this function is treated like any other character,\n\
6877 and `quit-flag' is not set.\n\
6879 If the key sequence starts with a mouse click, then the sequence is read\n\
6880 using the keymaps of the buffer of the window clicked in, not the buffer\n\
6881 of the selected window as normal.\n\
6883 `read-key-sequence' drops unbound button-down events, since you normally\n\
6884 only care about the click or drag events which follow them. If a drag\n\
6885 or multi-click event is unbound, but the corresponding click event would\n\
6886 be bound, `read-key-sequence' turns the event into a click event at the\n\
6887 drag's starting position. This means that you don't have to distinguish\n\
6888 between click and drag, double, or triple events unless you want to.\n\
6890 `read-key-sequence' prefixes mouse events on mode lines, the vertical\n\
6891 lines separating windows, and scroll bars with imaginary keys\n\
6892 `mode-line', `vertical-line', and `vertical-scroll-bar'.\n\
6894 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this\n\
6895 function will process a switch-frame event if the user switches frames\n\
6896 before typing anything. If the user switches frames in the middle of a\n\
6897 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME\n\
6898 is nil, then the event will be put off until after the current key sequence.\n\
6900 `read-key-sequence' checks `function-key-map' for function key\n\
6901 sequences, where they wouldn't conflict with ordinary bindings. See\n\
6902 `function-key-map' for more details.")
6903 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
)
6906 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 4, 0,
6908 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
)
6909 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
6910 Lisp_Object can_return_switch_frame
;
6912 Lisp_Object keybuf
[30];
6914 struct gcpro gcpro1
, gcpro2
;
6917 CHECK_STRING (prompt
, 0);
6920 bzero (keybuf
, sizeof keybuf
);
6922 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
6924 if (NILP (continue_echo
))
6926 this_command_key_count
= 0;
6927 this_single_command_key_start
= 0;
6930 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
6931 prompt
, ! NILP (dont_downcase_last
),
6932 ! NILP (can_return_switch_frame
), 0);
6940 return make_event_array (i
, keybuf
);
6943 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
6944 "Execute CMD as an editor command.\n\
6945 CMD must be a symbol that satisfies the `commandp' predicate.\n\
6946 Optional second arg RECORD-FLAG non-nil\n\
6947 means unconditionally put this command in `command-history'.\n\
6948 Otherwise, that is done only if an arg is read using the minibuffer.\n\
6949 The argument KEYS specifies the value to use instead of (this-command-keys)\n\
6950 when reading the arguments; if it is nil, (this-command-keys) is used.\n\
6951 The argument SPECIAL, if non-nil, means that this command is executing\n\
6952 a special event, so ignore the prefix argument and don't clear it.")
6953 (cmd
, record_flag
, keys
, special
)
6954 Lisp_Object cmd
, record_flag
, keys
, special
;
6956 register Lisp_Object final
;
6957 register Lisp_Object tem
;
6958 Lisp_Object prefixarg
;
6959 struct backtrace backtrace
;
6960 extern int debug_on_next_call
;
6962 debug_on_next_call
= 0;
6966 prefixarg
= current_kboard
->Vprefix_arg
;
6967 Vcurrent_prefix_arg
= prefixarg
;
6968 current_kboard
->Vprefix_arg
= Qnil
;
6975 tem
= Fget (cmd
, Qdisabled
);
6976 if (!NILP (tem
) && !NILP (Vrun_hooks
))
6978 tem
= Fsymbol_value (Qdisabled_command_hook
);
6980 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
6986 final
= Findirect_function (cmd
);
6988 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
6990 struct gcpro gcpro1
, gcpro2
;
6992 GCPRO2 (cmd
, prefixarg
);
6993 do_autoload (final
, cmd
);
7000 if (STRINGP (final
) || VECTORP (final
))
7002 /* If requested, place the macro in the command history. For
7003 other sorts of commands, call-interactively takes care of
7005 if (!NILP (record_flag
))
7007 = Fcons (Fcons (Qexecute_kbd_macro
,
7008 Fcons (final
, Fcons (prefixarg
, Qnil
))),
7011 return Fexecute_kbd_macro (final
, prefixarg
);
7013 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
7015 backtrace
.next
= backtrace_list
;
7016 backtrace_list
= &backtrace
;
7017 backtrace
.function
= &Qcall_interactively
;
7018 backtrace
.args
= &cmd
;
7019 backtrace
.nargs
= 1;
7020 backtrace
.evalargs
= 0;
7022 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
7024 backtrace_list
= backtrace
.next
;
7030 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
7032 "Read function name, then read its arguments and call it.")
7034 Lisp_Object prefixarg
;
7036 Lisp_Object function
;
7038 Lisp_Object saved_keys
;
7039 Lisp_Object bindings
, value
;
7040 struct gcpro gcpro1
, gcpro2
;
7042 saved_keys
= Fvector (this_command_key_count
,
7043 XVECTOR (this_command_keys
)->contents
);
7045 GCPRO2 (saved_keys
, prefixarg
);
7047 if (EQ (prefixarg
, Qminus
))
7049 else if (CONSP (prefixarg
) && XINT (XCONS (prefixarg
)->car
) == 4)
7050 strcpy (buf
, "C-u ");
7051 else if (CONSP (prefixarg
) && INTEGERP (XCONS (prefixarg
)->car
))
7053 if (sizeof (int) == sizeof (EMACS_INT
))
7054 sprintf (buf
, "%d ", XINT (XCONS (prefixarg
)->car
));
7055 else if (sizeof (long) == sizeof (EMACS_INT
))
7056 sprintf (buf
, "%ld ", XINT (XCONS (prefixarg
)->car
));
7060 else if (INTEGERP (prefixarg
))
7062 if (sizeof (int) == sizeof (EMACS_INT
))
7063 sprintf (buf
, "%d ", XINT (prefixarg
));
7064 else if (sizeof (long) == sizeof (EMACS_INT
))
7065 sprintf (buf
, "%ld ", XINT (prefixarg
));
7070 /* This isn't strictly correct if execute-extended-command
7071 is bound to anything else. Perhaps it should use
7072 this_command_keys? */
7073 strcat (buf
, "M-x ");
7075 /* Prompt with buf, and then read a string, completing from and
7076 restricting to the set of all defined commands. Don't provide
7077 any initial input. Save the command read on the extended-command
7079 function
= Fcompleting_read (build_string (buf
),
7080 Vobarray
, Qcommandp
,
7081 Qt
, Qnil
, Qextended_command_history
, Qnil
);
7083 if (STRINGP (function
) && XSTRING (function
)->size
== 0)
7084 error ("No command name given");
7086 /* Set this_command_keys to the concatenation of saved_keys and
7087 function, followed by a RET. */
7089 struct Lisp_String
*str
;
7094 this_command_key_count
= 0;
7095 this_single_command_key_start
= 0;
7097 keys
= XVECTOR (saved_keys
)->contents
;
7098 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
7099 add_command_key (keys
[i
]);
7101 str
= XSTRING (function
);
7102 for (i
= 0; i
< str
->size
; i
++)
7104 XSETFASTINT (tem
, str
->data
[i
]);
7105 add_command_key (tem
);
7108 XSETFASTINT (tem
, '\015');
7109 add_command_key (tem
);
7114 function
= Fintern (function
, Qnil
);
7115 current_kboard
->Vprefix_arg
= prefixarg
;
7116 this_command
= function
;
7118 /* If enabled, show which key runs this command. */
7119 if (!NILP (Vsuggest_key_bindings
)
7120 && NILP (Vexecuting_macro
)
7121 && SYMBOLP (function
))
7122 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
7128 GCPRO2 (bindings
, value
);
7129 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
7131 /* If the command has a key binding, print it now. */
7132 if (!NILP (bindings
))
7134 /* But first wait, and skip the message if there is input. */
7135 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
7136 ? Vsuggest_key_bindings
: make_number (2)),
7138 && ! CONSP (Vunread_command_events
))
7140 Lisp_Object binding
;
7142 char *oldmessage
= echo_area_glyphs
;
7143 int oldmessage_len
= echo_area_glyphs_length
;
7145 binding
= Fkey_description (bindings
);
7148 = (char *) alloca (XSYMBOL (function
)->name
->size
7149 + XSTRING (binding
)->size
7151 sprintf (newmessage
, "You can run the command `%s' by typing %s",
7152 XSYMBOL (function
)->name
->data
,
7153 XSTRING (binding
)->data
);
7154 message1_nolog (newmessage
);
7155 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
7156 ? Vsuggest_key_bindings
: make_number (2)),
7158 message2_nolog (oldmessage
, oldmessage_len
);
7162 RETURN_UNGCPRO (value
);
7165 /* Find the set of keymaps now active.
7166 Store into *MAPS_P a vector holding the various maps
7167 and return the number of them. The vector was malloc'd
7168 and the caller should free it. */
7171 current_active_maps (maps_p
)
7172 Lisp_Object
**maps_p
;
7174 Lisp_Object
*tmaps
, *maps
;
7177 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7178 if (!NILP (Voverriding_local_map_menu_flag
))
7180 /* Yes, use them (if non-nil) as well as the global map. */
7181 maps
= (Lisp_Object
*) xmalloc (3 * sizeof (maps
[0]));
7183 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7184 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7185 if (!NILP (Voverriding_local_map
))
7186 maps
[nmaps
++] = Voverriding_local_map
;
7190 /* No, so use major and minor mode keymaps. */
7191 nmaps
= current_minor_maps (NULL
, &tmaps
);
7192 maps
= (Lisp_Object
*) xmalloc ((nmaps
+ 2) * sizeof (maps
[0]));
7193 bcopy (tmaps
, maps
, nmaps
* sizeof (maps
[0]));
7194 #ifdef USE_TEXT_PROPERTIES
7195 maps
[nmaps
++] = get_local_map (PT
, current_buffer
);
7197 maps
[nmaps
++] = current_buffer
->keymap
;
7200 maps
[nmaps
++] = current_global_map
;
7206 /* Return nonzero if input events are pending. */
7208 detect_input_pending ()
7211 get_input_pending (&input_pending
, 0);
7213 return input_pending
;
7216 /* Return nonzero if input events are pending, and run any pending timers. */
7218 detect_input_pending_run_timers (do_display
)
7221 int old_timers_run
= timers_run
;
7224 get_input_pending (&input_pending
, 1);
7226 if (old_timers_run
!= timers_run
&& do_display
)
7227 redisplay_preserve_echo_area ();
7229 return input_pending
;
7232 /* This is called in some cases before a possible quit.
7233 It cases the next call to detect_input_pending to recompute input_pending.
7234 So calling this function unnecessarily can't do any harm. */
7235 clear_input_pending ()
7240 /* Return nonzero if there are pending requeued events.
7241 This isn't used yet. The hope is to make wait_reading_process_input
7242 call it, and return return if it runs Lisp code that unreads something.
7243 The problem is, kbd_buffer_get_event needs to be fixed to know what
7244 to do in that case. It isn't trivial. */
7246 requeued_events_pending_p ()
7248 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
7252 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
7253 "T if command input is currently available with no waiting.\n\
7254 Actually, the value is nil only if we can be sure that no input is available.")
7257 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
7260 get_input_pending (&input_pending
, 1);
7261 return input_pending
> 0 ? Qt
: Qnil
;
7264 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
7265 "Return vector of last 100 events, not counting those from keyboard macros.")
7268 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
7271 if (total_keys
< NUM_RECENT_KEYS
)
7272 return Fvector (total_keys
, keys
);
7275 val
= Fvector (NUM_RECENT_KEYS
, keys
);
7276 bcopy (keys
+ recent_keys_index
,
7277 XVECTOR (val
)->contents
,
7278 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
7280 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
7281 recent_keys_index
* sizeof (Lisp_Object
));
7286 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
7287 "Return the key sequence that invoked this command.\n\
7288 The value is a string or a vector.")
7291 return make_event_array (this_command_key_count
,
7292 XVECTOR (this_command_keys
)->contents
);
7295 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
7296 Sthis_single_command_keys
, 0, 0, 0,
7297 "Return the key sequence that invoked this command.\n\
7298 Unlike `this-command-keys', this function's value\n\
7299 does not include prefix arguments.\n\
7300 The value is a string or a vector.")
7303 return make_event_array (this_command_key_count
7304 - this_single_command_key_start
,
7305 (XVECTOR (this_command_keys
)->contents
7306 + this_single_command_key_start
));
7309 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
7310 Sreset_this_command_lengths
, 0, 0, 0,
7311 "Used for complicated reasons in `universal-argument-other-key'.\n\
7313 `universal-argument-other-key' rereads the event just typed.\n\
7314 It then gets translated through `function-key-map'.\n\
7315 The translated event gets included in the echo area and in\n\
7316 the value of `this-command-keys' in addition to the raw original event.\n\
7317 That is not right.\n\
7319 Calling this function directs the translated event to replace\n\
7320 the original event, so that only one version of the event actually\n\
7321 appears in the echo area and in the value of `this-command-keys.'.")
7324 before_command_restore_flag
= 1;
7325 before_command_key_count_1
= before_command_key_count
;
7326 before_command_echo_length_1
= before_command_echo_length
;
7329 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
7330 "Return the current depth in recursive edits.")
7334 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
7338 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
7339 "FOpen dribble file: ",
7340 "Start writing all keyboard characters to a dribble file called FILE.\n\
7341 If FILE is nil, close any open dribble file.")
7352 file
= Fexpand_file_name (file
, Qnil
);
7353 dribble
= fopen (XSTRING (file
)->data
, "w");
7355 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
7360 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
7361 "Discard the contents of the terminal input buffer.\n\
7362 Also cancel any kbd macro being defined.")
7365 current_kboard
->defining_kbd_macro
= Qnil
;
7366 update_mode_lines
++;
7368 Vunread_command_events
= Qnil
;
7369 unread_command_char
= -1;
7371 discard_tty_input ();
7373 /* Without the cast, GCC complains that this assignment loses the
7374 volatile qualifier of kbd_store_ptr. Is there anything wrong
7376 kbd_fetch_ptr
= (struct input_event
*) kbd_store_ptr
;
7377 Ffillarray (kbd_buffer_frame_or_window
, Qnil
);
7383 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
7384 "Stop Emacs and return to superior process. You can resume later.\n\
7385 If `cannot-suspend' is non-nil, or if the system doesn't support job\n\
7386 control, run a subshell instead.\n\n\
7387 If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
7388 to be read as terminal input by Emacs's parent, after suspension.\n\
7390 Before suspending, run the normal hook `suspend-hook'.\n\
7391 After resumption run the normal hook `suspend-resume-hook'.\n\
7393 Some operating systems cannot stop the Emacs process and resume it later.\n\
7394 On such systems, Emacs starts a subshell instead of suspending.")
7396 Lisp_Object stuffstring
;
7399 int count
= specpdl_ptr
- specpdl
;
7400 int old_height
, old_width
;
7402 struct gcpro gcpro1
, gcpro2
;
7403 extern init_sys_modes ();
7405 if (!NILP (stuffstring
))
7406 CHECK_STRING (stuffstring
, 0);
7408 /* Run the functions in suspend-hook. */
7409 if (!NILP (Vrun_hooks
))
7410 call1 (Vrun_hooks
, intern ("suspend-hook"));
7412 GCPRO1 (stuffstring
);
7413 get_frame_size (&old_width
, &old_height
);
7415 /* sys_suspend can get an error if it tries to fork a subshell
7416 and the system resources aren't available for that. */
7417 record_unwind_protect (init_sys_modes
, 0);
7418 stuff_buffered_input (stuffstring
);
7423 unbind_to (count
, Qnil
);
7425 /* Check if terminal/window size has changed.
7426 Note that this is not useful when we are running directly
7427 with a window system; but suspend should be disabled in that case. */
7428 get_frame_size (&width
, &height
);
7429 if (width
!= old_width
|| height
!= old_height
)
7430 change_frame_size (selected_frame
, height
, width
, 0, 0);
7432 /* Run suspend-resume-hook. */
7433 if (!NILP (Vrun_hooks
))
7434 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
7440 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
7441 Then in any case stuff anything Emacs has read ahead and not used. */
7443 stuff_buffered_input (stuffstring
)
7444 Lisp_Object stuffstring
;
7446 /* stuff_char works only in BSD, versions 4.2 and up. */
7449 register unsigned char *p
;
7451 if (STRINGP (stuffstring
))
7455 p
= XSTRING (stuffstring
)->data
;
7456 count
= XSTRING (stuffstring
)->size
;
7461 /* Anything we have read ahead, put back for the shell to read. */
7462 /* ?? What should this do when we have multiple keyboards??
7463 Should we ignore anything that was typed in at the "wrong" kboard? */
7464 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
7466 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
7467 kbd_fetch_ptr
= kbd_buffer
;
7468 if (kbd_fetch_ptr
->kind
== ascii_keystroke
)
7469 stuff_char (kbd_fetch_ptr
->code
);
7470 kbd_fetch_ptr
->kind
= no_event
;
7471 (XVECTOR (kbd_buffer_frame_or_window
)->contents
[kbd_fetch_ptr
7477 #endif /* BSD_SYSTEM and not BSD4_1 */
7480 set_waiting_for_input (time_to_clear
)
7481 EMACS_TIME
*time_to_clear
;
7483 input_available_clear_time
= time_to_clear
;
7485 /* Tell interrupt_signal to throw back to read_char, */
7486 waiting_for_input
= 1;
7488 /* If interrupt_signal was called before and buffered a C-g,
7489 make it run again now, to avoid timing error. */
7490 if (!NILP (Vquit_flag
))
7491 quit_throw_to_read_char ();
7494 clear_waiting_for_input ()
7496 /* Tell interrupt_signal not to throw back to read_char, */
7497 waiting_for_input
= 0;
7498 input_available_clear_time
= 0;
7501 /* This routine is called at interrupt level in response to C-G.
7502 If interrupt_input, this is the handler for SIGINT.
7503 Otherwise, it is called from kbd_buffer_store_event,
7504 in handling SIGIO or SIGTINT.
7506 If `waiting_for_input' is non zero, then unless `echoing' is nonzero,
7507 immediately throw back to read_char.
7509 Otherwise it sets the Lisp variable quit-flag not-nil.
7510 This causes eval to throw, when it gets a chance.
7511 If quit-flag is already non-nil, it stops the job right away. */
7514 interrupt_signal (signalnum
) /* If we don't have an argument, */
7515 int signalnum
; /* some compilers complain in signal calls. */
7518 /* Must preserve main program's value of errno. */
7519 int old_errno
= errno
;
7521 #if defined (USG) && !defined (POSIX_SIGNALS)
7522 if (!read_socket_hook
&& NILP (Vwindow_system
))
7524 /* USG systems forget handlers when they are used;
7525 must reestablish each time */
7526 signal (SIGINT
, interrupt_signal
);
7527 signal (SIGQUIT
, interrupt_signal
);
7533 if (!NILP (Vquit_flag
)
7534 && (FRAME_TERMCAP_P (selected_frame
) || FRAME_MSDOS_P (selected_frame
)))
7536 /* If SIGINT isn't blocked, don't let us be interrupted by
7537 another SIGINT, it might be harmful due to non-reentrancy
7538 in I/O functions. */
7539 sigblock (sigmask (SIGINT
));
7544 #ifdef SIGTSTP /* Support possible in later USG versions */
7546 * On systems which can suspend the current process and return to the original
7547 * shell, this command causes the user to end up back at the shell.
7548 * The "Auto-save" and "Abort" questions are not asked until
7549 * the user elects to return to emacs, at which point he can save the current
7550 * job and either dump core or continue.
7555 if (sys_suspend () == -1)
7557 printf ("Not running as a subprocess;\n");
7558 printf ("you can continue or abort.\n");
7561 /* Perhaps should really fork an inferior shell?
7562 But that would not provide any way to get back
7563 to the original shell, ever. */
7564 printf ("No support for stopping a process on this operating system;\n");
7565 printf ("you can continue or abort.\n");
7566 #endif /* not VMS */
7567 #endif /* not SIGTSTP */
7569 /* We must remain inside the screen area when the internal terminal
7570 is used. Note that [Enter] is not echoed by dos. */
7573 /* It doesn't work to autosave while GC is in progress;
7574 the code used for auto-saving doesn't cope with the mark bit. */
7575 if (!gc_in_progress
)
7577 printf ("Auto-save? (y or n) ");
7579 if (((c
= getchar ()) & ~040) == 'Y')
7581 Fdo_auto_save (Qt
, Qnil
);
7583 printf ("\r\nAuto-save done");
7584 #else /* not MSDOS */
7585 printf ("Auto-save done\n");
7586 #endif /* not MSDOS */
7588 while (c
!= '\n') c
= getchar ();
7592 /* During GC, it must be safe to reenable quitting again. */
7593 Vinhibit_quit
= Qnil
;
7596 #endif /* not MSDOS */
7597 printf ("Garbage collection in progress; cannot auto-save now\r\n");
7598 printf ("but will instead do a real quit after garbage collection ends\r\n");
7603 printf ("\r\nAbort? (y or n) ");
7604 #else /* not MSDOS */
7606 printf ("Abort (and enter debugger)? (y or n) ");
7608 printf ("Abort (and dump core)? (y or n) ");
7609 #endif /* not VMS */
7610 #endif /* not MSDOS */
7612 if (((c
= getchar ()) & ~040) == 'Y')
7614 while (c
!= '\n') c
= getchar ();
7616 printf ("\r\nContinuing...\r\n");
7617 #else /* not MSDOS */
7618 printf ("Continuing...\n");
7619 #endif /* not MSDOS */
7626 /* If executing a function that wants to be interrupted out of
7627 and the user has not deferred quitting by binding `inhibit-quit'
7628 then quit right away. */
7629 if (immediate_quit
&& NILP (Vinhibit_quit
))
7633 Fsignal (Qquit
, Qnil
);
7636 /* Else request quit when it's safe */
7640 if (waiting_for_input
&& !echoing
)
7641 quit_throw_to_read_char ();
7646 /* Handle a C-g by making read_char return C-g. */
7648 quit_throw_to_read_char ()
7650 quit_error_check ();
7652 /* Prevent another signal from doing this before we finish. */
7653 clear_waiting_for_input ();
7656 Vunread_command_events
= Qnil
;
7657 unread_command_char
= -1;
7659 #if 0 /* Currently, sit_for is called from read_char without turning
7660 off polling. And that can call set_waiting_for_input.
7661 It seems to be harmless. */
7662 #ifdef POLL_FOR_INPUT
7663 /* May be > 1 if in recursive minibuffer. */
7664 if (poll_suppress_count
== 0)
7668 if (FRAMEP (internal_last_event_frame
)
7669 && XFRAME (internal_last_event_frame
) != selected_frame
)
7670 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
7673 _longjmp (getcjmp
, 1);
7676 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
7677 "Set mode of reading keyboard input.\n\
7678 First arg INTERRUPT non-nil means use input interrupts;\n\
7679 nil means use CBREAK mode.\n\
7680 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal\n\
7681 (no effect except in CBREAK mode).\n\
7682 Third arg META t means accept 8-bit input (for a Meta key).\n\
7683 META nil means ignore the top bit, on the assumption it is parity.\n\
7684 Otherwise, accept 8-bit input and don't use the top bit for Meta.\n\
7685 Optional fourth arg QUIT if non-nil specifies character to use for quitting.\n\
7686 See also `current-input-mode'.")
7687 (interrupt
, flow
, meta
, quit
)
7688 Lisp_Object interrupt
, flow
, meta
, quit
;
7691 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
7692 error ("set-input-mode: QUIT must be an ASCII character");
7694 #ifdef POLL_FOR_INPUT
7699 /* this causes startup screen to be restored and messes with the mouse */
7704 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7705 if (read_socket_hook
)
7707 /* When using X, don't give the user a real choice,
7708 because we haven't implemented the mechanisms to support it. */
7709 #ifdef NO_SOCK_SIGIO
7710 interrupt_input
= 0;
7711 #else /* not NO_SOCK_SIGIO */
7712 interrupt_input
= 1;
7713 #endif /* NO_SOCK_SIGIO */
7716 interrupt_input
= !NILP (interrupt
);
7717 #else /* not SIGIO */
7718 interrupt_input
= 0;
7719 #endif /* not SIGIO */
7721 /* Our VMS input only works by interrupts, as of now. */
7723 interrupt_input
= 1;
7726 flow_control
= !NILP (flow
);
7729 else if (EQ (meta
, Qt
))
7734 /* Don't let this value be out of range. */
7735 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
7741 #ifdef POLL_FOR_INPUT
7742 poll_suppress_count
= 1;
7748 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
7749 "Return information about the way Emacs currently reads keyboard input.\n\
7750 The value is a list of the form (INTERRUPT FLOW META QUIT), where\n\
7751 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if\n\
7752 nil, Emacs is using CBREAK mode.\n\
7753 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the\n\
7754 terminal; this does not apply if Emacs uses interrupt-driven input.\n\
7755 META is t if accepting 8-bit input with 8th bit as Meta flag.\n\
7756 META nil means ignoring the top bit, on the assumption it is parity.\n\
7757 META is neither t nor nil if accepting 8-bit input and using\n\
7758 all 8 bits as the character code.\n\
7759 QUIT is the character Emacs currently uses to quit.\n\
7760 The elements of this list correspond to the arguments of\n\
7766 val
[0] = interrupt_input
? Qt
: Qnil
;
7767 val
[1] = flow_control
? Qt
: Qnil
;
7768 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
7769 XSETFASTINT (val
[3], quit_char
);
7771 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
7776 * Set up a new kboard object with reasonable initial values.
7782 kb
->Voverriding_terminal_local_map
= Qnil
;
7783 kb
->Vlast_command
= Qnil
;
7784 kb
->Vprefix_arg
= Qnil
;
7785 kb
->kbd_queue
= Qnil
;
7786 kb
->kbd_queue_has_data
= 0;
7787 kb
->immediate_echo
= 0;
7788 kb
->echoptr
= kb
->echobuf
;
7789 kb
->echo_after_prompt
= -1;
7790 kb
->kbd_macro_buffer
= 0;
7791 kb
->kbd_macro_bufsize
= 0;
7792 kb
->defining_kbd_macro
= Qnil
;
7793 kb
->Vlast_kbd_macro
= Qnil
;
7794 kb
->reference_count
= 0;
7795 kb
->Vsystem_key_alist
= Qnil
;
7796 kb
->system_key_syms
= Qnil
;
7797 kb
->Vdefault_minibuffer_frame
= Qnil
;
7801 * Destroy the contents of a kboard object, but not the object itself.
7802 * We use this just before deleting it, or if we're going to initialize
7809 if (kb
->kbd_macro_buffer
)
7810 xfree (kb
->kbd_macro_buffer
);
7819 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
7822 *kbp
= kb
->next_kboard
;
7830 /* This is correct before outermost invocation of the editor loop */
7831 command_loop_level
= -1;
7833 quit_char
= Ctl ('g');
7834 Vunread_command_events
= Qnil
;
7835 unread_command_char
= -1;
7836 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
7838 recent_keys_index
= 0;
7839 kbd_fetch_ptr
= kbd_buffer
;
7840 kbd_store_ptr
= kbd_buffer
;
7841 kbd_buffer_frame_or_window
7842 = Fmake_vector (make_number (KBD_BUFFER_SIZE
), Qnil
);
7844 do_mouse_tracking
= Qnil
;
7848 /* This means that command_loop_1 won't try to select anything the first
7850 internal_last_event_frame
= Qnil
;
7851 Vlast_event_frame
= internal_last_event_frame
;
7854 current_kboard
= initial_kboard
;
7856 wipe_kboard (current_kboard
);
7857 init_kboard (current_kboard
);
7860 Ffillarray (kbd_buffer_frame_or_window
, Qnil
);
7862 kbd_buffer_frame_or_window
7863 = Fmake_vector (make_number (KBD_BUFFER_SIZE
), Qnil
);
7864 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
7866 signal (SIGINT
, interrupt_signal
);
7867 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
7868 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
7869 SIGQUIT and we can't tell which one it will give us. */
7870 signal (SIGQUIT
, interrupt_signal
);
7871 #endif /* HAVE_TERMIO */
7873 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7875 if (!noninteractive
)
7876 signal (SIGIO
, input_available_signal
);
7879 /* Use interrupt input by default, if it works and noninterrupt input
7880 has deficiencies. */
7882 #ifdef INTERRUPT_INPUT
7883 interrupt_input
= 1;
7885 interrupt_input
= 0;
7888 /* Our VMS input only works by interrupts, as of now. */
7890 interrupt_input
= 1;
7896 if (keyboard_init_hook
)
7897 (*keyboard_init_hook
) ();
7899 #ifdef POLL_FOR_INPUT
7900 poll_suppress_count
= 1;
7905 /* This type's only use is in syms_of_keyboard, to initialize the
7906 event header symbols and put properties on them. */
7913 struct event_head head_table
[] = {
7914 &Qmouse_movement
, "mouse-movement", &Qmouse_movement
,
7915 &Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
,
7916 &Qswitch_frame
, "switch-frame", &Qswitch_frame
,
7917 &Qdelete_frame
, "delete-frame", &Qdelete_frame
,
7918 &Qiconify_frame
, "iconify-frame", &Qiconify_frame
,
7919 &Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
,
7924 Qtimer_event_handler
= intern ("timer-event-handler");
7925 staticpro (&Qtimer_event_handler
);
7927 Qdisabled_command_hook
= intern ("disabled-command-hook");
7928 staticpro (&Qdisabled_command_hook
);
7930 Qself_insert_command
= intern ("self-insert-command");
7931 staticpro (&Qself_insert_command
);
7933 Qforward_char
= intern ("forward-char");
7934 staticpro (&Qforward_char
);
7936 Qbackward_char
= intern ("backward-char");
7937 staticpro (&Qbackward_char
);
7939 Qdisabled
= intern ("disabled");
7940 staticpro (&Qdisabled
);
7942 Qundefined
= intern ("undefined");
7943 staticpro (&Qundefined
);
7945 Qpre_command_hook
= intern ("pre-command-hook");
7946 staticpro (&Qpre_command_hook
);
7948 Qpost_command_hook
= intern ("post-command-hook");
7949 staticpro (&Qpost_command_hook
);
7951 Qpost_command_idle_hook
= intern ("post-command-idle-hook");
7952 staticpro (&Qpost_command_idle_hook
);
7954 Qdeferred_action_function
= intern ("deferred-action-function");
7955 staticpro (&Qdeferred_action_function
);
7957 Qcommand_hook_internal
= intern ("command-hook-internal");
7958 staticpro (&Qcommand_hook_internal
);
7960 Qfunction_key
= intern ("function-key");
7961 staticpro (&Qfunction_key
);
7962 Qmouse_click
= intern ("mouse-click");
7963 staticpro (&Qmouse_click
);
7965 Qmenu_enable
= intern ("menu-enable");
7966 staticpro (&Qmenu_enable
);
7968 Qmode_line
= intern ("mode-line");
7969 staticpro (&Qmode_line
);
7970 Qvertical_line
= intern ("vertical-line");
7971 staticpro (&Qvertical_line
);
7972 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
7973 staticpro (&Qvertical_scroll_bar
);
7974 Qmenu_bar
= intern ("menu-bar");
7975 staticpro (&Qmenu_bar
);
7977 Qabove_handle
= intern ("above-handle");
7978 staticpro (&Qabove_handle
);
7979 Qhandle
= intern ("handle");
7980 staticpro (&Qhandle
);
7981 Qbelow_handle
= intern ("below-handle");
7982 staticpro (&Qbelow_handle
);
7983 Qup
= intern ("up");
7985 Qdown
= intern ("down");
7988 Qevent_kind
= intern ("event-kind");
7989 staticpro (&Qevent_kind
);
7990 Qevent_symbol_elements
= intern ("event-symbol-elements");
7991 staticpro (&Qevent_symbol_elements
);
7992 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
7993 staticpro (&Qevent_symbol_element_mask
);
7994 Qmodifier_cache
= intern ("modifier-cache");
7995 staticpro (&Qmodifier_cache
);
7997 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
7998 staticpro (&Qrecompute_lucid_menubar
);
7999 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
8000 staticpro (&Qactivate_menubar_hook
);
8002 Qpolling_period
= intern ("polling-period");
8003 staticpro (&Qpolling_period
);
8006 struct event_head
*p
;
8008 for (p
= head_table
;
8009 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
8012 *p
->var
= intern (p
->name
);
8014 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
8015 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
8019 button_down_location
= Fmake_vector (make_number (NUM_MOUSE_BUTTONS
), Qnil
);
8020 staticpro (&button_down_location
);
8024 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
8026 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
8027 for (i
= 0; i
< len
; i
++)
8028 if (modifier_names
[i
])
8029 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
8030 staticpro (&modifier_symbols
);
8033 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
8034 staticpro (&recent_keys
);
8036 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
8037 staticpro (&this_command_keys
);
8039 Qextended_command_history
= intern ("extended-command-history");
8040 Fset (Qextended_command_history
, Qnil
);
8041 staticpro (&Qextended_command_history
);
8043 kbd_buffer_frame_or_window
8044 = Fmake_vector (make_number (KBD_BUFFER_SIZE
), Qnil
);
8045 staticpro (&kbd_buffer_frame_or_window
);
8047 accent_key_syms
= Qnil
;
8048 staticpro (&accent_key_syms
);
8050 func_key_syms
= Qnil
;
8051 staticpro (&func_key_syms
);
8054 staticpro (&mouse_syms
);
8056 unread_switch_frame
= Qnil
;
8057 staticpro (&unread_switch_frame
);
8059 internal_last_event_frame
= Qnil
;
8060 staticpro (&internal_last_event_frame
);
8062 read_key_sequence_cmd
= Qnil
;
8063 staticpro (&read_key_sequence_cmd
);
8065 defsubr (&Sevent_convert_list
);
8066 defsubr (&Sread_key_sequence
);
8067 defsubr (&Srecursive_edit
);
8069 defsubr (&Strack_mouse
);
8071 defsubr (&Sinput_pending_p
);
8072 defsubr (&Scommand_execute
);
8073 defsubr (&Srecent_keys
);
8074 defsubr (&Sthis_command_keys
);
8075 defsubr (&Sthis_single_command_keys
);
8076 defsubr (&Sreset_this_command_lengths
);
8077 defsubr (&Ssuspend_emacs
);
8078 defsubr (&Sabort_recursive_edit
);
8079 defsubr (&Sexit_recursive_edit
);
8080 defsubr (&Srecursion_depth
);
8081 defsubr (&Stop_level
);
8082 defsubr (&Sdiscard_input
);
8083 defsubr (&Sopen_dribble_file
);
8084 defsubr (&Sset_input_mode
);
8085 defsubr (&Scurrent_input_mode
);
8086 defsubr (&Sexecute_extended_command
);
8088 DEFVAR_LISP ("last-command-char", &last_command_char
,
8089 "Last input event that was part of a command.");
8091 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
8092 "Last input event that was part of a command.");
8094 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
8095 "Last input event in a command, except for mouse menu events.\n\
8096 Mouse menus give back keys that don't look like mouse events;\n\
8097 this variable holds the actual mouse event that led to the menu,\n\
8098 so that you can determine whether the command was run by mouse or not.");
8100 DEFVAR_LISP ("last-input-char", &last_input_char
,
8101 "Last input event.");
8103 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
8104 "Last input event.");
8106 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
8107 "List of objects to be read as next command input events.");
8109 DEFVAR_INT ("unread-command-char", &unread_command_char
,
8110 "If not -1, an object to be read as next command input event.");
8112 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
8113 "Meta-prefix character code. Meta-foo as command input\n\
8114 turns into this character followed by foo.");
8115 XSETINT (meta_prefix_char
, 033);
8117 DEFVAR_KBOARD ("last-command", Vlast_command
,
8118 "The last command executed. Normally a symbol with a function definition,\n\
8119 but can be whatever was found in the keymap, or whatever the variable\n\
8120 `this-command' was set to by that command.\n\
8122 The value `mode-exit' is special; it means that the previous command\n\
8123 read an event that told it to exit, and it did so and unread that event.\n\
8124 In other words, the present command is the event that made the previous\n\
8127 The value `kill-region' is special; it means that the previous command\n\
8128 was a kill command.");
8130 DEFVAR_LISP ("this-command", &this_command
,
8131 "The command now being executed.\n\
8132 The command can set this variable; whatever is put here\n\
8133 will be in `last-command' during the following command.");
8134 this_command
= Qnil
;
8136 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
8137 "*Number of keyboard input characters between auto-saves.\n\
8138 Zero means disable autosaving due to number of characters typed.");
8139 auto_save_interval
= 300;
8141 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
8142 "*Number of seconds idle time before auto-save.\n\
8143 Zero or nil means disable auto-saving due to idleness.\n\
8144 After auto-saving due to this many seconds of idle time,\n\
8145 Emacs also does a garbage collection if that seems to be warranted.");
8146 XSETFASTINT (Vauto_save_timeout
, 30);
8148 DEFVAR_INT ("echo-keystrokes", &echo_keystrokes
,
8149 "*Nonzero means echo unfinished commands after this many seconds of pause.");
8150 echo_keystrokes
= 1;
8152 DEFVAR_INT ("polling-period", &polling_period
,
8153 "*Interval between polling for input during Lisp execution.\n\
8154 The reason for polling is to make C-g work to stop a running program.\n\
8155 Polling is needed only when using X windows and SIGIO does not work.\n\
8156 Polling is automatically disabled in all other cases.");
8159 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
8160 "*Maximum time between mouse clicks to make a double-click.\n\
8161 Measured in milliseconds. nil means disable double-click recognition;\n\
8162 t means double-clicks have no time limit and are detected\n\
8163 by position only.");
8164 Vdouble_click_time
= make_number (500);
8166 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
8167 "*Non-nil means inhibit local map menu bar menus.");
8168 inhibit_local_menu_bar_menus
= 0;
8170 DEFVAR_INT ("num-input-keys", &num_input_keys
,
8171 "Number of complete key sequences read as input so far.\n\
8172 This includes key sequences read from keyboard macros.\n\
8173 The number is effectively the number of interactive command invocations.");
8176 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
8177 "Number of input events read from the keyboard so far.\n\
8178 This does not include events generated by keyboard macros.");
8179 num_nonmacro_input_events
= 0;
8181 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
8182 "The frame in which the most recently read event occurred.\n\
8183 If the last event came from a keyboard macro, this is set to `macro'.");
8184 Vlast_event_frame
= Qnil
;
8186 /* This variable is set up in sysdep.c. */
8187 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
8188 "The ERASE character as set by the user with stty.");
8190 DEFVAR_LISP ("help-char", &Vhelp_char
,
8191 "Character to recognize as meaning Help.\n\
8192 When it is read, do `(eval help-form)', and display result if it's a string.\n\
8193 If the value of `help-form' is nil, this char can be read normally.");
8194 XSETINT (Vhelp_char
, Ctl ('H'));
8196 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
8197 "List of input events to recognize as meaning Help.\n\
8198 These work just like the value of `help-char' (see that).");
8199 Vhelp_event_list
= Qnil
;
8201 DEFVAR_LISP ("help-form", &Vhelp_form
,
8202 "Form to execute when character `help-char' is read.\n\
8203 If the form returns a string, that string is displayed.\n\
8204 If `help-form' is nil, the help char is not recognized.");
8207 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
8208 "Command to run when `help-char' character follows a prefix key.\n\
8209 This command is used only when there is no actual binding\n\
8210 for that character after that prefix key.");
8211 Vprefix_help_command
= Qnil
;
8213 DEFVAR_LISP ("top-level", &Vtop_level
,
8214 "Form to evaluate when Emacs starts up.\n\
8215 Useful to set before you dump a modified Emacs.");
8218 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
8219 "Translate table for keyboard input, or nil.\n\
8220 Each character is looked up in this string and the contents used instead.\n\
8221 The value may be a string, a vector, or a char-table.\n\
8222 If it is a string or vector of length N,\n\
8223 character codes N and up are untranslated.\n\
8224 In a vector or a char-table, an element which is nil means \"no translation\".");
8225 Vkeyboard_translate_table
= Qnil
;
8227 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
8228 "Non-nil means to always spawn a subshell instead of suspending,\n\
8229 even if the operating system has support for stopping a process.");
8232 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
8233 "Non-nil means prompt with menus when appropriate.\n\
8234 This is done when reading from a keymap that has a prompt string,\n\
8235 for elements that have prompt strings.\n\
8236 The menu is displayed on the screen\n\
8237 if X menus were enabled at configuration\n\
8238 time and the previous event was a mouse click prefix key.\n\
8239 Otherwise, menu prompting uses the echo area.");
8242 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
8243 "Character to see next line of menu prompt.\n\
8244 Type this character while in a menu prompt to rotate around the lines of it.");
8245 XSETINT (menu_prompt_more_char
, ' ');
8247 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
8248 "A mask of additional modifier keys to use with every keyboard character.\n\
8249 Emacs applies the modifiers of the character stored here to each keyboard\n\
8250 character it reads. For example, after evaluating the expression\n\
8251 (setq extra-keyboard-modifiers ?\\C-x)\n\
8252 all input characters will have the control modifier applied to them.\n\
8254 Note that the character ?\\C-@, equivalent to the integer zero, does\n\
8255 not count as a control character; rather, it counts as a character\n\
8256 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero\n\
8257 cancels any modification.");
8258 extra_keyboard_modifiers
= 0;
8260 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
8261 "If an editing command sets this to t, deactivate the mark afterward.\n\
8262 The command loop sets this to nil before each command,\n\
8263 and tests the value when the command returns.\n\
8264 Buffer modification stores t in this variable.");
8265 Vdeactivate_mark
= Qnil
;
8267 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
8268 "Temporary storage of pre-command-hook or post-command-hook.");
8269 Vcommand_hook_internal
= Qnil
;
8271 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
8272 "Normal hook run before each command is executed.\n\
8273 Errors running the hook are caught and ignored.");
8274 Vpre_command_hook
= Qnil
;
8276 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
8277 "Normal hook run after each command is executed.\n\
8278 Errors running the hook are caught and ignored.");
8279 Vpost_command_hook
= Qnil
;
8281 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook
,
8282 "Normal hook run after each command is executed, if idle.\n\
8283 Errors running the hook are caught and ignored.\n\
8284 This feature is obsolete; use idle timers instead. See `etc/NEWS'.");
8285 Vpost_command_idle_hook
= Qnil
;
8287 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay
,
8288 "Delay time before running `post-command-idle-hook'.\n\
8289 This is measured in microseconds.");
8290 post_command_idle_delay
= 100000;
8293 DEFVAR_LISP ("echo-area-clear-hook", ...,
8294 "Normal hook run when clearing the echo area.");
8296 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
8297 XSYMBOL (Qecho_area_clear_hook
)->value
= Qnil
;
8299 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
8300 "t means menu bar, specified Lucid style, needs to be recomputed.");
8301 Vlucid_menu_bar_dirty_flag
= Qnil
;
8303 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
8304 "List of menu bar items to move to the end of the menu bar.\n\
8305 The elements of the list are event types that may have menu bar bindings.");
8306 Vmenu_bar_final_items
= Qnil
;
8308 DEFVAR_KBOARD ("overriding-terminal-local-map",
8309 Voverriding_terminal_local_map
,
8310 "Per-terminal keymap that overrides all other local keymaps.\n\
8311 If this variable is non-nil, it is used as a keymap instead of the\n\
8312 buffer's local map, and the minor mode keymaps and text property keymaps.\n\
8313 This variable is intended to let commands such as `universal-argumemnt'\n\
8314 set up a different keymap for reading the next command.");
8316 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
8317 "Keymap that overrides all other local keymaps.\n\
8318 If this variable is non-nil, it is used as a keymap instead of the\n\
8319 buffer's local map, and the minor mode keymaps and text property keymaps.");
8320 Voverriding_local_map
= Qnil
;
8322 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
8323 "Non-nil means `overriding-local-map' applies to the menu bar.\n\
8324 Otherwise, the menu bar continues to reflect the buffer's local map\n\
8325 and the minor mode maps regardless of `overriding-local-map'.");
8326 Voverriding_local_map_menu_flag
= Qnil
;
8328 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
8329 "Keymap defining bindings for special events to execute at low level.");
8330 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
8332 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
8333 "*Non-nil means generate motion events for mouse motion.");
8335 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
8336 "Alist of system-specific X windows key symbols.\n\
8337 Each element should have the form (N . SYMBOL) where N is the\n\
8338 numeric keysym code (sans the \"system-specific\" bit 1<<28)\n\
8339 and SYMBOL is its name.");
8341 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
8342 "List of deferred actions to be performed at a later time.\n\
8343 The precise format isn't relevant here; we just check whether it is nil.");
8344 Vdeferred_action_list
= Qnil
;
8346 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
8347 "Function to call to handle deferred actions, after each command.\n\
8348 This function is called with no arguments after each command\n\
8349 whenever `deferred-action-list' is non-nil.");
8350 Vdeferred_action_function
= Qnil
;
8352 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
8353 "Non-nil means show the equivalent key-binding when M-x command has one.\n\
8354 The value can be a length of time to show the message for.\n\
8355 If the value is non-nil and not a number, we wait 2 seconds.");
8356 Vsuggest_key_bindings
= Qt
;
8358 DEFVAR_LISP ("timer-list", &Vtimer_list
,
8359 "List of active absolute time timers in order of increasing time");
8362 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
8363 "List of active idle-time timers in order of increasing time");
8364 Vtimer_idle_list
= Qnil
;
8369 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
8370 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
8371 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
8372 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
8373 initial_define_key (meta_map
, 'x', "execute-extended-command");
8375 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
8376 "handle-delete-frame");
8377 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
8379 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",