1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Allow config.h to undefine symbols found here. */
29 #include "termhooks.h"
36 #include "dispextern.h"
38 #include "intervals.h"
39 #include "blockinput.h"
48 #include <sys/ioctl.h>
50 #endif /* not MSDOS */
52 #include "syssignal.h"
55 /* This is to get the definitions of the XK_ symbols. */
60 /* Include systime.h after xterm.h to avoid double inclusion of time.h. */
65 /* Variables for blockinput.h: */
67 /* Non-zero if interrupt input is blocked right now. */
68 int interrupt_input_blocked
;
70 /* Nonzero means an input interrupt has arrived
71 during the current critical section. */
72 int interrupt_input_pending
;
75 /* File descriptor to use for input. */
79 /* Make all keyboard buffers much bigger when using X windows. */
80 #define KBD_BUFFER_SIZE 4096
81 #else /* No X-windows, character input */
82 #define KBD_BUFFER_SIZE 256
83 #endif /* No X-windows */
85 /* Following definition copied from eval.c */
89 struct backtrace
*next
;
90 Lisp_Object
*function
;
91 Lisp_Object
*args
; /* Points to vector of args. */
92 int nargs
; /* length of vector. If nargs is UNEVALLED,
93 args points to slot holding list of
98 PERDISPLAY the_only_perdisplay
;
100 /* Non-nil disable property on a command means
101 do not execute it; call disabled-command-hook's value instead. */
102 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
104 #define NUM_RECENT_KEYS (100)
105 int recent_keys_index
; /* Index for storing next element into recent_keys */
106 int total_keys
; /* Total number of elements stored into recent_keys */
107 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
109 /* Vector holding the key sequence that invoked the current command.
110 It is reused for each command, and it may be longer than the current
111 sequence; this_command_key_count indicates how many elements
112 actually mean something.
113 It's easier to staticpro a single Lisp_Object than an array. */
114 Lisp_Object this_command_keys
;
115 int this_command_key_count
;
117 extern int minbuf_level
;
119 extern struct backtrace
*backtrace_list
;
121 /* Nonzero means do menu prompting. */
122 static int menu_prompting
;
124 /* Character to see next line of menu prompt. */
125 static Lisp_Object menu_prompt_more_char
;
127 /* For longjmp to where kbd input is being done. */
128 static jmp_buf getcjmp
;
130 /* True while doing kbd input. */
131 int waiting_for_input
;
133 /* True while displaying for echoing. Delays C-g throwing. */
136 /* Nonzero means disregard local maps for the menu bar. */
137 static int inhibit_local_menu_bar_menus
;
139 /* Nonzero means C-g should cause immediate error-signal. */
142 /* Character to recognize as the help char. */
143 Lisp_Object Vhelp_char
;
145 /* Form to execute when help char is typed. */
146 Lisp_Object Vhelp_form
;
148 /* Command to run when the help character follows a prefix key. */
149 Lisp_Object Vprefix_help_command
;
151 /* List of items that should move to the end of the menu bar. */
152 Lisp_Object Vmenu_bar_final_items
;
154 /* Character that causes a quit. Normally C-g.
156 If we are running on an ordinary terminal, this must be an ordinary
157 ASCII char, since we want to make it our interrupt character.
159 If we are not running on an ordinary terminal, it still needs to be
160 an ordinary ASCII char. This character needs to be recognized in
161 the input interrupt handler. At this point, the keystroke is
162 represented as a struct input_event, while the desired quit
163 character is specified as a lispy event. The mapping from struct
164 input_events to lispy events cannot run in an interrupt handler,
165 and the reverse mapping is difficult for anything but ASCII
168 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
172 extern Lisp_Object current_global_map
;
173 extern int minibuf_level
;
175 /* If non-nil, this is a map that overrides all other local maps. */
176 Lisp_Object Voverriding_local_map
;
178 /* If non-nil, Voverriding_local_map applies to the menu bar. */
179 Lisp_Object Voverriding_local_map_menu_flag
;
181 /* Current depth in recursive edits. */
182 int command_loop_level
;
184 /* Total number of times command_loop has read a key sequence. */
187 /* Last input character read as a command. */
188 Lisp_Object last_command_char
;
190 /* Last input character read as a command, not counting menus
191 reached by the mouse. */
192 Lisp_Object last_nonmenu_event
;
194 /* Last input character read for any purpose. */
195 Lisp_Object last_input_char
;
197 /* If not Qnil, a list of objects to be read as subsequent command input. */
198 Lisp_Object Vunread_command_events
;
200 /* If not -1, an event to be read as subsequent command input. */
201 int unread_command_char
;
203 /* If not Qnil, this is a switch-frame event which we decided to put
204 off until the end of a key sequence. This should be read as the
205 next command input, after any unread_command_events.
207 read_key_sequence uses this to delay switch-frame events until the
208 end of the key sequence; Fread_char uses it to put off switch-frame
209 events until a non-ASCII event is acceptable as input. */
210 Lisp_Object unread_switch_frame
;
212 /* A mask of extra modifier bits to put into every keyboard char. */
213 int extra_keyboard_modifiers
;
215 /* Char to use as prefix when a meta character is typed in.
216 This is bound on entry to minibuffer in case ESC is changed there. */
218 Lisp_Object meta_prefix_char
;
220 /* Last size recorded for a current buffer which is not a minibuffer. */
221 static int last_non_minibuf_size
;
223 /* Number of idle seconds before an auto-save and garbage collection. */
224 static Lisp_Object Vauto_save_timeout
;
226 /* Total number of times read_char has returned. */
229 /* Total number of times read_char has returned, outside of macros. */
230 int num_nonmacro_input_chars
;
232 /* Auto-save automatically when this many characters have been typed
233 since the last time. */
235 static int auto_save_interval
;
237 /* Value of num_nonmacro_input_chars as of last auto save. */
241 /* Last command executed by the editor command loop, not counting
242 commands that set the prefix argument. */
244 Lisp_Object last_command
;
246 /* The command being executed by the command loop.
247 Commands may set this, and the value set will be copied into last_command
248 instead of the actual command. */
249 Lisp_Object this_command
;
251 /* The value of point when the last command was executed. */
252 int last_point_position
;
254 /* The buffer that was current when the last command was started. */
255 Lisp_Object last_point_position_buffer
;
258 /* The frame in which the last input event occurred, or Qmacro if the
259 last event came from a macro. We use this to determine when to
260 generate switch-frame events. This may be cleared by functions
261 like Fselect_frame, to make sure that a switch-frame event is
262 generated by the next character. */
263 Lisp_Object internal_last_event_frame
;
266 /* A user-visible version of the above, intended to allow users to
267 figure out where the last event came from, if the event doesn't
268 carry that information itself (i.e. if it was a character). */
269 Lisp_Object Vlast_event_frame
;
271 /* The timestamp of the last input event we received from the X server.
272 X Windows wants this for selection ownership. */
273 unsigned long last_event_timestamp
;
275 Lisp_Object Qself_insert_command
;
276 Lisp_Object Qforward_char
;
277 Lisp_Object Qbackward_char
;
278 Lisp_Object Qundefined
;
280 /* read_key_sequence stores here the command definition of the
281 key sequence that it reads. */
282 Lisp_Object read_key_sequence_cmd
;
284 /* Form to evaluate (if non-nil) when Emacs is started. */
285 Lisp_Object Vtop_level
;
287 /* User-supplied string to translate input characters through. */
288 Lisp_Object Vkeyboard_translate_table
;
290 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
291 extern Lisp_Object Vfunction_key_map
;
293 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
294 Lisp_Object Vkey_translation_map
;
296 /* Non-nil means deactivate the mark at end of this command. */
297 Lisp_Object Vdeactivate_mark
;
299 /* Menu bar specified in Lucid Emacs fashion. */
301 Lisp_Object Vlucid_menu_bar_dirty_flag
;
302 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
304 /* Hooks to run before and after each command. */
305 Lisp_Object Qpre_command_hook
, Qpost_command_hook
;
306 Lisp_Object Vpre_command_hook
, Vpost_command_hook
;
307 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
309 /* List of deferred actions to be performed at a later time.
310 The precise format isn't relevant here; we just check whether it is nil. */
311 Lisp_Object Vdeferred_action_list
;
313 /* Function to call to handle deferred actions, when there are any. */
314 Lisp_Object Vdeferred_action_function
;
315 Lisp_Object Qdeferred_action_function
;
317 /* File in which we write all commands we read. */
320 /* Nonzero if input is available. */
323 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
324 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
328 extern char *pending_malloc_warning
;
331 /* If this flag is a frame, we check mouse_moved to see when the
332 mouse moves, and motion events will appear in the input stream.
333 Otherwise, mouse motion is ignored. */
334 static Lisp_Object do_mouse_tracking
;
336 /* The window system handling code should set this if the mouse has
337 moved since the last call to the mouse_position_hook. Calling that
338 hook should clear this. Code assumes that if this is set, it can
339 call mouse_position_hook to get the promised position, so don't set
340 it unless you're prepared to substantiate the claim! */
343 #define MOUSE_ACTIVITY_AVAILABLE (FRAMEP (do_mouse_tracking) && mouse_moved)
344 #else /* Not HAVE_MOUSE. */
345 #define MOUSE_ACTIVITY_AVAILABLE 0
346 #endif /* HAVE_MOUSE. */
348 /* Symbols to head events. */
349 Lisp_Object Qmouse_movement
;
350 Lisp_Object Qscroll_bar_movement
;
351 Lisp_Object Qswitch_frame
;
352 Lisp_Object Qdelete_frame
;
353 Lisp_Object Qiconify_frame
;
354 Lisp_Object Qmake_frame_visible
;
356 /* Symbols to denote kinds of events. */
357 Lisp_Object Qfunction_key
;
358 Lisp_Object Qmouse_click
;
359 /* Lisp_Object Qmouse_movement; - also an event header */
361 /* Properties of event headers. */
362 Lisp_Object Qevent_kind
;
363 Lisp_Object Qevent_symbol_elements
;
365 Lisp_Object Qmenu_enable
;
367 /* An event header symbol HEAD may have a property named
368 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
369 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
370 mask of modifiers applied to it. If present, this is used to help
371 speed up parse_modifiers. */
372 Lisp_Object Qevent_symbol_element_mask
;
374 /* An unmodified event header BASE may have a property named
375 Qmodifier_cache, which is an alist mapping modifier masks onto
376 modified versions of BASE. If present, this helps speed up
378 Lisp_Object Qmodifier_cache
;
380 /* Symbols to use for parts of windows. */
381 Lisp_Object Qmode_line
;
382 Lisp_Object Qvertical_line
;
383 Lisp_Object Qvertical_scroll_bar
;
384 Lisp_Object Qmenu_bar
;
386 extern Lisp_Object Qmenu_enable
;
388 Lisp_Object
recursive_edit_unwind (), command_loop ();
389 Lisp_Object
Fthis_command_keys ();
390 Lisp_Object Qextended_command_history
;
392 Lisp_Object Qpolling_period
;
394 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
396 EMACS_TIME
*input_available_clear_time
;
398 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
399 Default is 1 if INTERRUPT_INPUT is defined. */
402 /* Nonzero while interrupts are temporarily deferred during redisplay. */
403 int interrupts_deferred
;
405 /* nonzero means use ^S/^Q for flow control. */
408 /* Allow m- file to inhibit use of FIONREAD. */
409 #ifdef BROKEN_FIONREAD
413 /* We are unable to use interrupts if FIONREAD is not available,
414 so flush SIGIO so we won't try. */
421 /* If we support X Windows, turn on the code to poll periodically
422 to detect C-g. It isn't actually used when doing interrupt input. */
423 #ifdef HAVE_X_WINDOWS
424 #define POLL_FOR_INPUT
427 /* Global variable declarations. */
429 /* Function for init_keyboard to call with no args (if nonzero). */
430 void (*keyboard_init_hook
) ();
432 static int read_avail_input ();
433 static void get_input_pending ();
434 static int readable_events ();
435 static Lisp_Object
read_char_x_menu_prompt ();
436 static Lisp_Object
read_char_minibuf_menu_prompt ();
437 static Lisp_Object
make_lispy_event ();
438 static Lisp_Object
make_lispy_movement ();
439 static Lisp_Object
modify_event_symbol ();
440 static Lisp_Object
make_lispy_switch_frame ();
442 /* > 0 if we are to echo keystrokes. */
443 static int echo_keystrokes
;
445 /* Nonzero means don't try to suspend even if the operating system seems
447 static int cannot_suspend
;
449 #define min(a,b) ((a)<(b)?(a):(b))
450 #define max(a,b) ((a)>(b)?(a):(b))
452 /* Install the string STR as the beginning of the string of echoing,
453 so that it serves as a prompt for the next character.
454 Also start echoing. */
459 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
460 int len
= strlen (str
);
462 if (len
> ECHOBUFSIZE
- 4)
463 len
= ECHOBUFSIZE
- 4;
464 bcopy (str
, perd
->echobuf
, len
);
465 perd
->echoptr
= perd
->echobuf
+ len
;
466 *perd
->echoptr
= '\0';
468 perd
->echo_after_prompt
= len
;
473 /* Add C to the echo string, if echoing is going on.
474 C can be a character, which is printed prettily ("M-C-x" and all that
475 jazz), or a symbol, whose name is printed. */
480 extern char *push_key_description ();
481 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
483 if (perd
->immediate_echo
)
485 char *ptr
= perd
->echoptr
;
487 if (ptr
!= perd
->echobuf
)
490 /* If someone has passed us a composite event, use its head symbol. */
495 if (ptr
- perd
->echobuf
> ECHOBUFSIZE
- 6)
498 ptr
= push_key_description (XINT (c
), ptr
);
500 else if (SYMBOLP (c
))
502 struct Lisp_String
*name
= XSYMBOL (c
)->name
;
503 if (((ptr
- perd
->echobuf
) + name
->size
+ 4) > ECHOBUFSIZE
)
505 bcopy (name
->data
, ptr
, name
->size
);
509 if (perd
->echoptr
== perd
->echobuf
&& EQ (c
, Vhelp_char
))
511 strcpy (ptr
, " (Type ? for further options)");
522 /* Temporarily add a dash to the end of the echo string if it's not
523 empty, so that it serves as a mini-prompt for the very next character. */
527 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
528 if (!perd
->immediate_echo
&& perd
->echoptr
== perd
->echobuf
)
530 /* Do nothing if we just printed a prompt. */
531 if (perd
->echo_after_prompt
== perd
->echoptr
- perd
->echobuf
)
533 /* Do nothing if not echoing at all. */
534 if (perd
->echoptr
== 0)
537 /* Put a dash at the end of the buffer temporarily,
538 but make it go away when the next character is added. */
539 perd
->echoptr
[0] = '-';
540 perd
->echoptr
[1] = 0;
545 /* Display the current echo string, and begin echoing if not already
550 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
551 if (!perd
->immediate_echo
)
554 perd
->immediate_echo
= 1;
556 for (i
= 0; i
< this_command_key_count
; i
++)
559 c
= XVECTOR (this_command_keys
)->contents
[i
];
560 if (! (EVENT_HAS_PARAMETERS (c
)
561 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
568 message2_nolog (perd
->echobuf
, strlen (perd
->echobuf
));
571 if (waiting_for_input
&& !NILP (Vquit_flag
))
572 quit_throw_to_read_char ();
575 /* Turn off echoing, for the start of a new command. */
579 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
580 perd
->immediate_echo
= 0;
581 perd
->echoptr
= perd
->echobuf
;
582 perd
->echo_after_prompt
= -1;
585 /* Return the length of the current echo string. */
590 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
591 return perd
->echoptr
- perd
->echobuf
;
594 /* Truncate the current echo message to its first LEN chars.
595 This and echo_char get used by read_key_sequence when the user
596 switches frames while entering a key sequence. */
602 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
603 perd
->echobuf
[len
] = '\0';
604 perd
->echoptr
= perd
->echobuf
+ len
;
605 truncate_echo_area (len
);
609 /* Functions for manipulating this_command_keys. */
611 add_command_key (key
)
614 int size
= XVECTOR (this_command_keys
)->size
;
616 if (this_command_key_count
>= size
)
618 Lisp_Object new_keys
;
620 new_keys
= Fmake_vector (make_number (size
* 2), Qnil
);
621 bcopy (XVECTOR (this_command_keys
)->contents
,
622 XVECTOR (new_keys
)->contents
,
623 size
* sizeof (Lisp_Object
));
625 this_command_keys
= new_keys
;
628 XVECTOR (this_command_keys
)->contents
[this_command_key_count
++] = key
;
634 int count
= specpdl_ptr
- specpdl
;
637 if (command_loop_level
> 0)
639 specbind (Qstandard_output
, Qt
);
640 specbind (Qstandard_input
, Qt
);
643 val
= command_loop ();
645 Fsignal (Qquit
, Qnil
);
647 return unbind_to (count
, Qnil
);
650 /* When an auto-save happens, record the "time", and don't do again soon. */
654 last_auto_save
= num_nonmacro_input_chars
;
657 /* Make an auto save happen as soon as possible at command level. */
659 force_auto_save_soon ()
661 last_auto_save
= - auto_save_interval
- 1;
663 record_asynch_buffer_change ();
666 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
667 "Invoke the editor command loop recursively.\n\
668 To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
669 that tells this function to return.\n\
670 Alternately, `(throw 'exit t)' makes this function signal an error.\n\
671 This function is called by the editor initialization to begin editing.")
674 int count
= specpdl_ptr
- specpdl
;
677 command_loop_level
++;
678 update_mode_lines
= 1;
680 record_unwind_protect (recursive_edit_unwind
,
682 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
686 return unbind_to (count
, Qnil
);
690 recursive_edit_unwind (buffer
)
694 Fset_buffer (buffer
);
696 command_loop_level
--;
697 update_mode_lines
= 1;
705 Vstandard_output
= Qt
;
706 Vstandard_input
= Qt
;
707 Vexecuting_macro
= Qnil
;
708 cmd_error_internal (data
, 0);
712 Vinhibit_quit
= Qnil
;
714 return make_number (0);
717 cmd_error_internal (data
, context
)
721 Lisp_Object errmsg
, tail
, errname
, file_error
;
728 echo_area_glyphs
= 0;
730 /* If the window system or terminal frame hasn't been initialized
731 yet, or we're not interactive, it's best to dump this message out
732 to stderr and exit. */
733 if (! FRAME_MESSAGE_BUF (selected_frame
)
735 stream
= Qexternal_debugging_output
;
744 write_string_1 (context
, -1, stream
);
746 errname
= Fcar (data
);
748 if (EQ (errname
, Qerror
))
751 if (!CONSP (data
)) data
= Qnil
;
752 errmsg
= Fcar (data
);
757 errmsg
= Fget (errname
, Qerror_message
);
758 file_error
= Fmemq (Qfile_error
,
759 Fget (errname
, Qerror_conditions
));
762 /* Print an error message including the data items.
763 This is done by printing it into a scratch buffer
764 and then making a copy of the text in the buffer. */
766 if (!CONSP (data
)) data
= Qnil
;
770 /* For file-error, make error message by concatenating
771 all the data items. They are all strings. */
772 if (!NILP (file_error
) && !NILP (tail
))
773 errmsg
= XCONS (tail
)->car
, tail
= XCONS (tail
)->cdr
;
775 if (STRINGP (errmsg
))
776 Fprinc (errmsg
, stream
);
778 write_string_1 ("peculiar error", -1, stream
);
780 for (i
= 0; CONSP (tail
); tail
= Fcdr (tail
), i
++)
782 write_string_1 (i
? ", " : ": ", 2, stream
);
783 if (!NILP (file_error
))
784 Fprinc (Fcar (tail
), stream
);
786 Fprin1 (Fcar (tail
), stream
);
790 /* If the window system or terminal frame hasn't been initialized
791 yet, or we're in -batch mode, this error should cause Emacs to exit. */
792 if (! FRAME_MESSAGE_BUF (selected_frame
)
796 Fkill_emacs (make_number (-1));
800 Lisp_Object
command_loop_1 ();
801 Lisp_Object
command_loop_2 ();
802 Lisp_Object
top_level_1 ();
804 /* Entry to editor-command-loop.
805 This level has the catches for exiting/returning to editor command loop.
806 It returns nil to exit recursive edit, t to abort it. */
811 if (command_loop_level
> 0 || minibuf_level
> 0)
813 return internal_catch (Qexit
, command_loop_2
, Qnil
);
818 internal_catch (Qtop_level
, top_level_1
, Qnil
);
819 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
821 /* End of file in -batch run causes exit here. */
827 /* Here we catch errors in execution of commands within the
828 editing loop, and reenter the editing loop.
829 When there is an error, cmd_error runs and returns a non-nil
830 value to us. A value of nil means that cmd_loop_1 itself
831 returned due to end of file (or end of kbd macro). */
836 register Lisp_Object val
;
839 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
848 return Feval (Vtop_level
);
854 /* On entry to the outer level, run the startup file */
855 if (!NILP (Vtop_level
))
856 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
857 else if (!NILP (Vpurify_flag
))
858 message ("Bare impure Emacs (standard Lisp code not loaded)");
860 message ("Bare Emacs (standard Lisp code not loaded)");
864 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
865 "Exit all recursive editing levels.")
868 Fthrow (Qtop_level
, Qnil
);
871 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
872 "Exit from the innermost recursive edit or minibuffer.")
875 if (command_loop_level
> 0 || minibuf_level
> 0)
876 Fthrow (Qexit
, Qnil
);
878 error ("No recursive edit is in progress");
881 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
882 "Abort the command that requested this recursive edit or minibuffer input.")
885 if (command_loop_level
> 0 || minibuf_level
> 0)
888 error ("No recursive edit is in progress");
891 /* This is the actual command reading loop,
892 sans error-handling encapsulation. */
894 Lisp_Object
Fcommand_execute ();
895 static int read_key_sequence ();
896 static void safe_run_hooks ();
901 Lisp_Object cmd
, tem
;
904 Lisp_Object keybuf
[30];
909 struct buffer
*prev_buffer
;
912 Vdeactivate_mark
= Qnil
;
913 waiting_for_input
= 0;
918 this_command_key_count
= 0;
920 /* Make sure this hook runs after commands that get errors and
921 throw to top level. */
922 /* Note that the value cell will never directly contain nil
923 if the symbol is a local variable. */
924 if (!NILP (XSYMBOL (Qpost_command_hook
)->value
) && !NILP (Vrun_hooks
))
925 safe_run_hooks (Qpost_command_hook
);
927 if (!NILP (Vdeferred_action_list
))
928 call0 (Vdeferred_action_function
);
930 /* Do this after running Vpost_command_hook, for consistency. */
931 last_command
= this_command
;
935 /* Install chars successfully executed in kbd macro. */
937 if (defining_kbd_macro
&& NILP (Vprefix_arg
))
938 finalize_kbd_macro_chars ();
940 /* Make sure the current window's buffer is selected. */
941 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
942 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
944 /* Display any malloc warning that just came out. Use while because
945 displaying one warning can cause another. */
947 while (pending_malloc_warning
)
948 display_malloc_warning ();
952 Vdeactivate_mark
= Qnil
;
954 /* If minibuffer on and echo area in use,
955 wait 2 sec and redraw minibuffer. */
957 if (minibuf_level
&& echo_area_glyphs
)
959 /* Bind inhibit-quit to t so that C-g gets read in
960 rather than quitting back to the minibuffer. */
961 int count
= specpdl_ptr
- specpdl
;
962 specbind (Qinhibit_quit
, Qt
);
963 Fsit_for (make_number (2), Qnil
, Qnil
);
964 unbind_to (count
, Qnil
);
966 echo_area_glyphs
= 0;
968 if (!NILP (Vquit_flag
))
971 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
976 alloca (0); /* Cause a garbage collection now */
977 /* Since we can free the most stuff here. */
978 #endif /* C_ALLOCA */
982 /* Select the frame that the last event came from. Usually,
983 switch-frame events will take care of this, but if some lisp
984 code swallows a switch-frame event, we'll fix things up here.
985 Is this a good idea? */
986 if (FRAMEP (internal_last_event_frame
)
987 && XFRAME (internal_last_event_frame
) != selected_frame
)
988 Fselect_frame (internal_last_event_frame
, Qnil
);
991 /* If it has changed current-menubar from previous value,
992 really recompute the menubar from the value. */
993 if (! NILP (Vlucid_menu_bar_dirty_flag
)
994 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
995 call0 (Qrecompute_lucid_menubar
);
997 /* Read next key sequence; i gets its length. */
998 i
= read_key_sequence (keybuf
, (sizeof keybuf
/ sizeof (keybuf
[0])), Qnil
, 0);
1002 /* Now we have read a key sequence of length I,
1003 or else I is 0 and we found end of file. */
1005 if (i
== 0) /* End of file -- happens only in */
1006 return Qnil
; /* a kbd macro, at the end. */
1007 /* -1 means read_key_sequence got a menu that was rejected.
1008 Just loop around and read another command. */
1012 this_command_key_count
= 0;
1016 last_command_char
= keybuf
[i
- 1];
1018 /* If the previous command tried to force a specific window-start,
1019 forget about that, in case this command moves point far away
1020 from that position. */
1021 XWINDOW (selected_window
)->force_start
= Qnil
;
1023 cmd
= read_key_sequence_cmd
;
1024 if (!NILP (Vexecuting_macro
))
1026 if (!NILP (Vquit_flag
))
1028 Vexecuting_macro
= Qt
;
1029 QUIT
; /* Make some noise. */
1030 /* Will return since macro now empty. */
1034 /* Do redisplay processing after this command except in special
1035 cases identified below that set no_redisplay to 1.
1036 (actually, there's currently no way to prevent the redisplay,
1037 and no_redisplay is ignored.
1038 Perhaps someday we will really implement it. */
1041 prev_buffer
= current_buffer
;
1042 prev_modiff
= MODIFF
;
1043 last_point_position
= PT
;
1044 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1046 /* Execute the command. */
1049 /* Note that the value cell will never directly contain nil
1050 if the symbol is a local variable. */
1051 if (!NILP (XSYMBOL (Qpre_command_hook
)->value
) && !NILP (Vrun_hooks
))
1052 safe_run_hooks (Qpre_command_hook
);
1054 if (NILP (this_command
))
1056 /* nil means key is undefined. */
1058 defining_kbd_macro
= 0;
1059 update_mode_lines
= 1;
1065 if (NILP (Vprefix_arg
) && ! no_direct
)
1067 /* Recognize some common commands in common situations and
1068 do them directly. */
1069 if (EQ (this_command
, Qforward_char
) && PT
< ZV
)
1071 struct Lisp_Vector
*dp
1072 = window_display_table (XWINDOW (selected_window
));
1073 lose
= FETCH_CHAR (PT
);
1076 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1077 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1078 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1079 && (lose
>= 0x20 && lose
< 0x7f)))
1080 : (lose
>= 0x20 && lose
< 0x7f))
1081 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1083 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1085 && !windows_or_buffers_changed
1086 && EQ (current_buffer
->selective_display
, Qnil
)
1087 && !detect_input_pending ()
1088 && NILP (Vexecuting_macro
))
1089 no_redisplay
= direct_output_forward_char (1);
1092 else if (EQ (this_command
, Qbackward_char
) && PT
> BEGV
)
1094 struct Lisp_Vector
*dp
1095 = window_display_table (XWINDOW (selected_window
));
1097 lose
= FETCH_CHAR (PT
);
1099 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1100 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1101 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1102 && (lose
>= 0x20 && lose
< 0x7f)))
1103 : (lose
>= 0x20 && lose
< 0x7f))
1104 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1106 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1108 && !windows_or_buffers_changed
1109 && EQ (current_buffer
->selective_display
, Qnil
)
1110 && !detect_input_pending ()
1111 && NILP (Vexecuting_macro
))
1112 no_redisplay
= direct_output_forward_char (-1);
1115 else if (EQ (this_command
, Qself_insert_command
)
1116 /* Try this optimization only on ascii keystrokes. */
1117 && INTEGERP (last_command_char
))
1119 unsigned char c
= XINT (last_command_char
);
1122 if (NILP (Vexecuting_macro
)
1123 && !EQ (minibuf_window
, selected_window
))
1125 if (!nonundocount
|| nonundocount
>= 20)
1132 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1134 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1136 || MODIFF
<= SAVE_MODIFF
1137 || windows_or_buffers_changed
1138 || !EQ (current_buffer
->selective_display
, Qnil
)
1139 || detect_input_pending ()
1140 || !NILP (Vexecuting_macro
));
1141 value
= internal_self_insert (c
, 0);
1148 && (PT
== ZV
|| FETCH_CHAR (PT
) == '\n'))
1150 struct Lisp_Vector
*dp
1151 = window_display_table (XWINDOW (selected_window
));
1158 obj
= DISP_CHAR_VECTOR (dp
, lose
);
1161 /* Do it only for char codes
1162 that by default display as themselves. */
1163 if (lose
>= 0x20 && lose
<= 0x7e)
1164 no_redisplay
= direct_output_for_insert (lose
);
1166 else if (VECTORP (obj
)
1167 && XVECTOR (obj
)->size
== 1
1168 && (obj
= XVECTOR (obj
)->contents
[0],
1170 /* Insist face not specified in glyph. */
1171 && (XINT (obj
) & ((-1) << 8)) == 0)
1173 = direct_output_for_insert (XINT (obj
));
1177 if (lose
>= 0x20 && lose
<= 0x7e)
1178 no_redisplay
= direct_output_for_insert (lose
);
1185 /* Here for a command that isn't executed directly */
1188 if (NILP (Vprefix_arg
))
1190 Fcommand_execute (this_command
, Qnil
);
1195 /* Note that the value cell will never directly contain nil
1196 if the symbol is a local variable. */
1197 if (!NILP (XSYMBOL (Qpost_command_hook
)->value
) && !NILP (Vrun_hooks
))
1198 safe_run_hooks (Qpost_command_hook
);
1200 if (!NILP (Vdeferred_action_list
))
1201 safe_run_hooks (Qdeferred_action_function
);
1203 /* If there is a prefix argument,
1204 1) We don't want last_command to be ``universal-argument''
1205 (that would be dumb), so don't set last_command,
1206 2) we want to leave echoing on so that the prefix will be
1207 echoed as part of this key sequence, so don't call
1209 3) we want to leave this_command_key_count non-zero, so that
1210 read_char will realize that it is re-reading a character, and
1211 not echo it a second time. */
1212 if (NILP (Vprefix_arg
))
1214 last_command
= this_command
;
1216 this_command_key_count
= 0;
1219 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1221 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1223 current_buffer
->mark_active
= Qnil
;
1224 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1226 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1227 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1232 /* If we get an error while running the hook, cause the hook variable
1233 to be nil. Also inhibit quits, so that C-g won't cause the hook
1234 to mysteriously evaporate. */
1236 safe_run_hooks (hook
)
1240 int count
= specpdl_ptr
- specpdl
;
1241 specbind (Qinhibit_quit
, Qt
);
1243 /* We read and set the variable with functions,
1244 in case it's buffer-local. */
1245 value
= Vcommand_hook_internal
= Fsymbol_value (hook
);
1247 call1 (Vrun_hooks
, Qcommand_hook_internal
);
1250 unbind_to (count
, Qnil
);
1253 /* Number of seconds between polling for input. */
1256 /* Nonzero means polling for input is temporarily suppressed. */
1257 int poll_suppress_count
;
1259 /* Nonzero if polling_for_input is actually being used. */
1260 int polling_for_input
;
1262 #ifdef POLL_FOR_INPUT
1264 /* Handle an alarm once each second and read pending input
1265 so as to handle a C-g if it comces in. */
1268 input_poll_signal ()
1270 if (interrupt_input_blocked
== 0
1271 && !waiting_for_input
)
1272 read_avail_input (0);
1273 signal (SIGALRM
, input_poll_signal
);
1274 alarm (polling_period
);
1279 /* Begin signals to poll for input, if they are appropriate.
1280 This function is called unconditionally from various places. */
1284 #ifdef POLL_FOR_INPUT
1285 if (read_socket_hook
&& !interrupt_input
)
1287 poll_suppress_count
--;
1288 if (poll_suppress_count
== 0)
1290 signal (SIGALRM
, input_poll_signal
);
1291 polling_for_input
= 1;
1292 alarm (polling_period
);
1298 /* Nonzero if we are using polling to handle input asynchronously. */
1301 input_polling_used ()
1303 #ifdef POLL_FOR_INPUT
1304 return read_socket_hook
&& !interrupt_input
;
1310 /* Turn off polling. */
1314 #ifdef POLL_FOR_INPUT
1315 if (read_socket_hook
&& !interrupt_input
)
1317 if (poll_suppress_count
== 0)
1319 polling_for_input
= 0;
1322 poll_suppress_count
++;
1327 /* Set the value of poll_suppress_count to COUNT
1328 and start or stop polling accordingly. */
1331 set_poll_suppress_count (count
)
1334 #ifdef POLL_FOR_INPUT
1335 if (count
== 0 && poll_suppress_count
!= 0)
1337 poll_suppress_count
= 1;
1340 else if (count
!= 0 && poll_suppress_count
== 0)
1344 poll_suppress_count
= count
;
1348 /* Bind polling_period to a value at least N.
1349 But don't decrease it. */
1351 bind_polling_period (n
)
1354 #ifdef POLL_FOR_INPUT
1355 int new = polling_period
;
1361 specbind (Qpolling_period
, make_number (new));
1362 /* Start a new alarm with the new period. */
1367 /* Applying the control modifier to CHARACTER. */
1372 /* Save the upper bits here. */
1373 int upper
= c
& ~0177;
1377 /* Everything in the columns containing the upper-case letters
1378 denotes a control character. */
1379 if (c
>= 0100 && c
< 0140)
1383 /* Set the shift modifier for a control char
1384 made from a shifted letter. But only for letters! */
1385 if (oc
>= 'A' && oc
<= 'Z')
1386 c
|= shift_modifier
;
1389 /* The lower-case letters denote control characters too. */
1390 else if (c
>= 'a' && c
<= 'z')
1393 /* Include the bits for control and shift
1394 only if the basic ASCII code can't indicate them. */
1398 /* Replace the high bits. */
1399 c
|= (upper
& ~ctrl_modifier
);
1406 /* Input of single characters from keyboard */
1408 Lisp_Object
print_help ();
1409 static Lisp_Object
kbd_buffer_get_event ();
1410 static void record_char ();
1412 /* read a character from the keyboard; call the redisplay if needed */
1413 /* commandflag 0 means do not do auto-saving, but do do redisplay.
1414 -1 means do not do redisplay, but do do autosaving.
1417 /* The arguments MAPS and NMAPS are for menu prompting.
1418 MAPS is an array of keymaps; NMAPS is the length of MAPS.
1420 PREV_EVENT is the previous input event, or nil if we are reading
1421 the first event of a key sequence.
1423 If USED_MOUSE_MENU is non-zero, then we set *USED_MOUSE_MENU to 1
1424 if we used a mouse menu to read the input, or zero otherwise. If
1425 USED_MOUSE_MENU is zero, *USED_MOUSE_MENU is left alone.
1427 Value is t if we showed a menu and the user rejected it. */
1430 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
1434 Lisp_Object prev_event
;
1435 int *used_mouse_menu
;
1437 register Lisp_Object c
;
1440 int key_already_recorded
= 0;
1441 PERDISPLAY
*perd
= get_perdisplay (selected_frame
);
1442 Lisp_Object also_record
;
1445 if (CONSP (Vunread_command_events
))
1447 c
= XCONS (Vunread_command_events
)->car
;
1448 Vunread_command_events
= XCONS (Vunread_command_events
)->cdr
;
1450 if (this_command_key_count
== 0)
1456 if (unread_command_char
!= -1)
1458 XSETINT (c
, unread_command_char
);
1459 unread_command_char
= -1;
1461 if (this_command_key_count
== 0)
1467 if (!NILP (Vexecuting_macro
))
1470 /* We set this to Qmacro; since that's not a frame, nobody will
1471 try to switch frames on us, and the selected window will
1474 Since this event came from a macro, it would be misleading to
1475 leave internal_last_event_frame set to wherever the last
1476 real event came from. Normally, a switch-frame event selects
1477 internal_last_event_frame after each command is read, but
1478 events read from a macro should never cause a new frame to be
1480 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
1483 /* Exit the macro if we are at the end.
1484 Also, some things replace the macro with t
1485 to force an early exit. */
1486 if (EQ (Vexecuting_macro
, Qt
)
1487 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
1493 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
1494 if (STRINGP (Vexecuting_macro
)
1495 && (XINT (c
) & 0x80))
1496 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
1498 executing_macro_index
++;
1503 if (!NILP (unread_switch_frame
))
1505 c
= unread_switch_frame
;
1506 unread_switch_frame
= Qnil
;
1508 /* This event should make it into this_command_keys, and get echoed
1509 again, so we go to reread_first, rather than reread. */
1513 /* Don't bother updating menu bars while doing mouse tracking.
1514 We get events very rapidly then, and the menu bar won't be changing.
1515 We do update the menu bar once on entry to Ftrack_mouse. */
1516 if (commandflag
> 0 && !input_pending
&& !detect_input_pending ())
1517 prepare_menu_bars ();
1519 /* Save outer setjmp data, in case called recursively. */
1520 save_getcjmp (save_jump
);
1524 if (commandflag
>= 0 && !input_pending
&& !detect_input_pending ())
1527 if (_setjmp (getcjmp
))
1529 XSETINT (c
, quit_char
);
1531 XSETFRAME (internal_last_event_frame
, selected_frame
);
1532 Vlast_event_frame
= internal_last_event_frame
;
1534 /* If we report the quit char as an event,
1535 don't do so more than once. */
1536 if (!NILP (Vinhibit_quit
))
1542 /* Message turns off echoing unless more keystrokes turn it on again. */
1543 if (echo_area_glyphs
&& *echo_area_glyphs
&& echo_area_glyphs
!= perd
->echobuf
)
1546 /* If already echoing, continue. */
1549 /* Try reading a character via menu prompting in the minibuf.
1550 Try this before the sit-for, because the sit-for
1551 would do the wrong thing if we are supposed to do
1552 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
1553 after a mouse event so don't try a minibuf menu. */
1555 if (nmaps
> 0 && INTERACTIVE
1556 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
1557 /* Don't bring up a menu if we already have another event. */
1558 && NILP (Vunread_command_events
)
1559 && unread_command_char
< 0
1560 && !detect_input_pending ())
1562 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
1565 key_already_recorded
= 1;
1570 /* If in middle of key sequence and minibuffer not active,
1571 start echoing if enough time elapses. */
1572 if (minibuf_level
== 0 && !perd
->immediate_echo
&& this_command_key_count
> 0
1574 && echo_keystrokes
> 0
1575 && (echo_area_glyphs
== 0 || *echo_area_glyphs
== 0))
1579 /* After a mouse event, start echoing right away.
1580 This is because we are probably about to display a menu,
1581 and we don't want to delay before doing so. */
1582 if (EVENT_HAS_PARAMETERS (prev_event
))
1586 tem0
= sit_for (echo_keystrokes
, 0, 1, 1);
1592 /* Maybe auto save due to number of keystrokes or idle time. */
1594 if (commandflag
!= 0
1595 && auto_save_interval
> 0
1596 && num_nonmacro_input_chars
- last_auto_save
> max (auto_save_interval
, 20)
1597 && !detect_input_pending ())
1600 save_getcjmp (temp
);
1601 Fdo_auto_save (Qnil
, Qnil
);
1602 /* Hooks can actually change some buffers in auto save. */
1604 restore_getcjmp (temp
);
1607 /* Try reading using an X menu.
1608 This is never confused with reading using the minibuf
1609 because the recursive call of read_char in read_char_minibuf_menu_prompt
1610 does not pass on any keymaps. */
1611 if (nmaps
> 0 && INTERACTIVE
1612 && !NILP (prev_event
) && EVENT_HAS_PARAMETERS (prev_event
)
1613 /* Don't bring up a menu if we already have another event. */
1614 && NILP (Vunread_command_events
)
1615 && unread_command_char
< 0)
1616 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
1618 /* Slow down auto saves logarithmically in size of current buffer,
1619 and garbage collect while we're at it. */
1620 if (INTERACTIVE
&& NILP (c
))
1622 int delay_level
, buffer_size
;
1624 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
1625 last_non_minibuf_size
= Z
- BEG
;
1626 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
1628 while (buffer_size
> 64)
1629 delay_level
++, buffer_size
-= buffer_size
>> 2;
1630 if (delay_level
< 4) delay_level
= 4;
1631 /* delay_level is 4 for files under around 50k, 7 at 100k,
1632 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
1634 /* Auto save if enough time goes by without input. */
1635 if (commandflag
!= 0
1636 && num_nonmacro_input_chars
> last_auto_save
1637 && INTEGERP (Vauto_save_timeout
)
1638 && XINT (Vauto_save_timeout
) > 0)
1641 int delay
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
1642 tem0
= sit_for (delay
, 0, 1, 1);
1646 save_getcjmp (temp
);
1647 Fdo_auto_save (Qnil
, Qnil
);
1648 restore_getcjmp (temp
);
1650 /* If we have auto-saved and there is still no input
1651 available, garbage collect if there has been enough
1652 consing going on to make it worthwhile. */
1653 if (!detect_input_pending ()
1654 && consing_since_gc
> gc_cons_threshold
/ 2)
1655 Fgarbage_collect ();
1656 /* prepare_menu_bars isn't safe here, but it should
1657 also be unnecessary. */
1663 /* Actually read a character, waiting if necessary. */
1666 c
= kbd_buffer_get_event ();
1669 if (commandflag
>= 0 && !input_pending
&& !detect_input_pending ())
1671 prepare_menu_bars ();
1676 /* Terminate Emacs in batch mode if at eof. */
1677 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
1678 Fkill_emacs (make_number (1));
1682 /* Add in any extra modifiers, where appropriate. */
1683 if ((extra_keyboard_modifiers
& CHAR_CTL
)
1684 || ((extra_keyboard_modifiers
& 0177) < ' '
1685 && (extra_keyboard_modifiers
& 0177) != 0))
1686 XSETINT (c
, make_ctrl_char (XINT (c
)));
1688 /* Transfer any other modifier bits directly from
1689 extra_keyboard_modifiers to c. Ignore the actual character code
1690 in the low 16 bits of extra_keyboard_modifiers. */
1691 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
1696 restore_getcjmp (save_jump
);
1700 /* Buffer switch events are only for internal wakeups
1701 so don't show them to the user. */
1705 if (key_already_recorded
)
1708 /* Wipe the echo area. */
1709 echo_area_glyphs
= 0;
1711 /* Handle things that only apply to characters. */
1714 /* If kbd_buffer_get_event gave us an EOF, return that. */
1718 if (STRINGP (Vkeyboard_translate_table
)
1719 && XSTRING (Vkeyboard_translate_table
)->size
> XFASTINT (c
))
1720 XSETINT (c
, XSTRING (Vkeyboard_translate_table
)->data
[XFASTINT (c
)]);
1723 /* If this event is a mouse click in the menu bar,
1724 return just menu-bar for now. Modify the mouse click event
1725 so we won't do this twice, then queue it up. */
1726 if (EVENT_HAS_PARAMETERS (c
)
1727 && CONSP (XCONS (c
)->cdr
)
1728 && CONSP (EVENT_START (c
))
1729 && CONSP (XCONS (EVENT_START (c
))->cdr
))
1733 posn
= POSN_BUFFER_POSN (EVENT_START (c
));
1734 /* Handle menu-bar events:
1735 insert the dummy prefix event `menu-bar'. */
1736 if (EQ (posn
, Qmenu_bar
))
1738 /* Change menu-bar to (menu-bar) as the event "position". */
1739 POSN_BUFFER_POSN (EVENT_START (c
)) = Fcons (posn
, Qnil
);
1742 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
1748 if (! NILP (also_record
))
1749 record_char (also_record
);
1754 /* Don't echo mouse motion events. */
1756 && ! (EVENT_HAS_PARAMETERS (c
)
1757 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
1760 if (! NILP (also_record
))
1761 echo_char (also_record
);
1764 /* Record this character as part of the current key. */
1765 add_command_key (c
);
1766 if (! NILP (also_record
))
1767 add_command_key (also_record
);
1769 /* Re-reading in the middle of a command */
1771 last_input_char
= c
;
1774 /* Process the help character specially if enabled */
1775 if (EQ (c
, Vhelp_char
) && !NILP (Vhelp_form
))
1778 count
= specpdl_ptr
- specpdl
;
1780 record_unwind_protect (Fset_window_configuration
,
1781 Fcurrent_window_configuration (Qnil
));
1783 tem0
= Feval (Vhelp_form
);
1785 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
1789 c
= read_char (0, 0, 0, Qnil
, 0);
1790 while (BUFFERP (c
));
1791 /* Remove the help from the frame */
1792 unbind_to (count
, Qnil
);
1793 prepare_menu_bars ();
1795 if (EQ (c
, make_number (040)))
1799 c
= read_char (0, 0, 0, Qnil
, 0);
1800 while (BUFFERP (c
));
1807 /* Record the input event C in various ways. */
1814 XVECTOR (recent_keys
)->contents
[recent_keys_index
] = c
;
1815 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
1816 recent_keys_index
= 0;
1818 /* Write c to the dribble file. If c is a lispy event, write
1819 the event's symbol to the dribble file, in <brackets>. Bleaugh.
1820 If you, dear reader, have a better idea, you've got the source. :-) */
1825 if (XUINT (c
) < 0x100)
1826 putc (XINT (c
), dribble
);
1828 fprintf (dribble
, " 0x%x", XUINT (c
));
1832 Lisp_Object dribblee
;
1834 /* If it's a structured event, take the event header. */
1835 dribblee
= EVENT_HEAD (c
);
1837 if (SYMBOLP (dribblee
))
1839 putc ('<', dribble
);
1840 fwrite (XSYMBOL (dribblee
)->name
->data
, sizeof (char),
1841 XSYMBOL (dribblee
)->name
->size
,
1843 putc ('>', dribble
);
1850 store_kbd_macro_char (c
);
1852 num_nonmacro_input_chars
++;
1859 struct buffer
*old
= current_buffer
;
1860 Fprinc (object
, Qnil
);
1861 set_buffer_internal (XBUFFER (Vstandard_output
));
1862 call0 (intern ("help-mode"));
1863 set_buffer_internal (old
);
1867 /* Copy out or in the info on where C-g should throw to.
1868 This is used when running Lisp code from within get_char,
1869 in case get_char is called recursively.
1870 See read_process_output. */
1875 bcopy (getcjmp
, temp
, sizeof getcjmp
);
1878 restore_getcjmp (temp
)
1881 bcopy (temp
, getcjmp
, sizeof getcjmp
);
1887 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1888 of this function. */
1891 tracking_off (old_value
)
1892 Lisp_Object old_value
;
1894 do_mouse_tracking
= old_value
;
1895 if (NILP (old_value
))
1897 /* Redisplay may have been preempted because there was input
1898 available, and it assumes it will be called again after the
1899 input has been processed. If the only input available was
1900 the sort that we have just disabled, then we need to call
1902 if (!readable_events ())
1904 prepare_menu_bars ();
1905 redisplay_preserve_echo_area ();
1906 get_input_pending (&input_pending
);
1911 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1912 "Evaluate BODY with mouse movement events enabled.\n\
1913 Within a `track-mouse' form, mouse motion generates input events that\n\
1914 you can read with `read-event'.\n\
1915 Normally, mouse motion is ignored.")
1919 int count
= specpdl_ptr
- specpdl
;
1922 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1924 if (!input_pending
&& !detect_input_pending ())
1925 prepare_menu_bars ();
1927 XSETFRAME (do_mouse_tracking
, selected_frame
);
1929 val
= Fprogn (args
);
1930 return unbind_to (count
, val
);
1933 #endif /* HAVE_MOUSE */
1935 /* Low level keyboard/mouse input.
1936 kbd_buffer_store_event places events in kbd_buffer, and
1937 kbd_buffer_get_event retrieves them.
1938 mouse_moved indicates when the mouse has moved again, and
1939 *mouse_position_hook provides the mouse position. */
1942 find_active_event_queue ()
1945 perd
= &the_only_perdisplay
;
1946 /* FOR_ALL_PERDISPLAYS (perd) */
1948 if (perd
->kbd_fetch_ptr
!= perd
->kbd_store_ptr
)
1954 /* Return true iff there are any events in the queue that read-char
1955 would return. If this returns false, a read-char would block. */
1959 return find_active_event_queue () != NULL
|| MOUSE_ACTIVITY_AVAILABLE
;
1962 /* Set this for debugging, to have a way to get out */
1965 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
1968 kbd_buffer_store_event (event
)
1969 register struct input_event
*event
;
1971 PERDISPLAY
*perd
= get_perdisplay (XFRAME (event
->frame_or_window
));
1973 if (event
->kind
== no_event
)
1976 if (event
->kind
== ascii_keystroke
)
1978 register int c
= event
->code
& 0377;
1980 if (event
->modifiers
& ctrl_modifier
)
1981 c
= make_ctrl_char (c
);
1983 c
|= (event
->modifiers
1984 & (meta_modifier
| alt_modifier
1985 | hyper_modifier
| super_modifier
));
1989 extern SIGTYPE
interrupt_signal ();
1992 /* If this results in a quit_char being returned to Emacs as
1993 input, set Vlast_event_frame properly. If this doesn't
1994 get returned to Emacs as an event, the next event read
1995 will set Vlast_event_frame again, so this is safe to do. */
1999 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
2001 internal_last_event_frame
= event
->frame_or_window
;
2003 internal_last_event_frame
= focus
;
2004 Vlast_event_frame
= internal_last_event_frame
;
2008 last_event_timestamp
= event
->timestamp
;
2009 interrupt_signal ();
2013 if (c
&& c
== stop_character
)
2020 if (perd
->kbd_store_ptr
- perd
->kbd_buffer
== KBD_BUFFER_SIZE
)
2021 perd
->kbd_store_ptr
= perd
->kbd_buffer
;
2023 /* Don't let the very last slot in the buffer become full,
2024 since that would make the two pointers equal,
2025 and that is indistinguishable from an empty buffer.
2026 Discard the event if it would fill the last slot. */
2027 if (perd
->kbd_fetch_ptr
- 1 != perd
->kbd_store_ptr
)
2029 volatile struct input_event
*sp
= perd
->kbd_store_ptr
;
2030 sp
->kind
= event
->kind
;
2031 if (event
->kind
== selection_request_event
)
2033 /* We must not use the ordinary copying code for this case,
2034 since `part' is an enum and copying it might not copy enough
2036 bcopy (event
, (char *) sp
, sizeof (*event
));
2040 sp
->code
= event
->code
;
2041 sp
->part
= event
->part
;
2042 sp
->frame_or_window
= event
->frame_or_window
;
2043 sp
->modifiers
= event
->modifiers
;
2046 sp
->timestamp
= event
->timestamp
;
2048 (XVECTOR (perd
->kbd_buffer_frame_or_window
)->contents
[perd
->kbd_store_ptr
2050 = event
->frame_or_window
);
2052 perd
->kbd_store_ptr
++;
2056 /* Read one event from the event buffer, waiting if necessary.
2057 The value is a Lisp object representing the event.
2058 The value is nil for an event that should be ignored,
2059 or that was handled here.
2060 We always read and discard one event. */
2063 kbd_buffer_get_event ()
2076 /* Wait until there is input available. */
2079 perd
= find_active_event_queue ();
2080 if (perd
|| MOUSE_ACTIVITY_AVAILABLE
)
2083 /* If the quit flag is set, then read_char will return
2084 quit_char, so that counts as "available input." */
2085 if (!NILP (Vquit_flag
))
2086 quit_throw_to_read_char ();
2088 /* One way or another, wait until input is available; then, if
2089 interrupt handlers have not read it, read it now. */
2092 wait_for_kbd_input ();
2094 /* Note SIGIO has been undef'd if FIONREAD is missing. */
2098 perd
= find_active_event_queue ();
2099 if (!(perd
|| MOUSE_ACTIVITY_AVAILABLE
))
2101 Lisp_Object minus_one
;
2103 XSETINT (minus_one
, -1);
2104 wait_reading_process_input (0, 0, minus_one
, 1);
2106 if (!interrupt_input
&& find_active_event_queue () == NULL
)
2107 /* Pass 1 for EXPECT since we just waited to have input. */
2108 read_avail_input (1);
2110 #endif /* not VMS */
2113 /* At this point, we know that there is a readable event available
2114 somewhere. If the event queue is empty, then there must be a
2115 mouse movement enabled and available. */
2118 struct input_event
*event
;
2120 event
= ((perd
->kbd_fetch_ptr
< perd
->kbd_buffer
+ KBD_BUFFER_SIZE
)
2121 ? perd
->kbd_fetch_ptr
2122 : perd
->kbd_buffer
);
2124 last_event_timestamp
= event
->timestamp
;
2128 /* These two kinds of events get special handling
2129 and don't actually appear to the command loop.
2130 We return nil for them. */
2131 if (event
->kind
== selection_request_event
)
2134 x_handle_selection_request (event
);
2135 perd
->kbd_fetch_ptr
= event
+ 1;
2137 /* We're getting selection request events, but we don't have
2143 else if (event
->kind
== selection_clear_event
)
2146 x_handle_selection_clear (event
);
2147 perd
->kbd_fetch_ptr
= event
+ 1;
2149 /* We're getting selection request events, but we don't have
2155 else if (event
->kind
== delete_window_event
)
2157 /* Make an event (delete-frame (FRAME)). */
2158 obj
= Fcons (event
->frame_or_window
, Qnil
);
2159 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
2160 perd
->kbd_fetch_ptr
= event
+ 1;
2162 else if (event
->kind
== iconify_event
)
2164 /* Make an event (iconify-frame (FRAME)). */
2165 obj
= Fcons (event
->frame_or_window
, Qnil
);
2166 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
2167 perd
->kbd_fetch_ptr
= event
+ 1;
2169 else if (event
->kind
== deiconify_event
)
2171 /* Make an event (make-frame-visible (FRAME)). */
2172 obj
= Fcons (event
->frame_or_window
, Qnil
);
2173 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
2174 perd
->kbd_fetch_ptr
= event
+ 1;
2177 else if (event
->kind
== menu_bar_event
)
2179 /* The event value is in the frame_or_window slot. */
2180 obj
= event
->frame_or_window
;
2181 perd
->kbd_fetch_ptr
= event
+ 1;
2183 else if (event
->kind
== buffer_switch_event
)
2185 /* The value doesn't matter here; only the type is tested. */
2186 XSETBUFFER (obj
, current_buffer
);
2187 perd
->kbd_fetch_ptr
= event
+ 1;
2189 /* Just discard these, by returning nil.
2190 (They shouldn't be found in the buffer,
2191 but on some machines it appears they do show up.) */
2192 else if (event
->kind
== no_event
)
2193 perd
->kbd_fetch_ptr
= event
+ 1;
2195 /* If this event is on a different frame, return a switch-frame this
2196 time, and leave the event in the queue for next time. */
2203 frame
= event
->frame_or_window
;
2204 if (WINDOWP (frame
))
2205 frame
= WINDOW_FRAME (XWINDOW (frame
));
2207 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
2211 if (! EQ (frame
, internal_last_event_frame
)
2212 && XFRAME (frame
) != selected_frame
)
2213 obj
= make_lispy_switch_frame (frame
);
2214 internal_last_event_frame
= frame
;
2215 #endif /* MULTI_FRAME */
2217 /* If we didn't decide to make a switch-frame event, go ahead
2218 and build a real event from the queue entry. */
2222 obj
= make_lispy_event (event
);
2224 /* Wipe out this event, to catch bugs. */
2225 event
->kind
= no_event
;
2226 XVECTOR (perd
->kbd_buffer_frame_or_window
)->contents
[event
- perd
->kbd_buffer
] = Qnil
;
2228 perd
->kbd_fetch_ptr
= event
+ 1;
2233 /* Try generating a mouse motion event. */
2234 else if (FRAMEP (do_mouse_tracking
) && mouse_moved
)
2236 FRAME_PTR f
= XFRAME (do_mouse_tracking
);
2237 Lisp_Object bar_window
;
2238 enum scroll_bar_part part
;
2242 /* Note that this uses F to determine which display to look at.
2243 If there is no valid info, it does not store anything
2244 so x remains nil. */
2246 (*mouse_position_hook
) (&f
, &bar_window
, &part
, &x
, &y
, &time
);
2251 /* Decide if we should generate a switch-frame event. Don't
2252 generate switch-frame events for motion outside of all Emacs
2258 frame
= FRAME_FOCUS_FRAME (f
);
2260 XSETFRAME (frame
, f
);
2262 if (! EQ (frame
, internal_last_event_frame
)
2263 && XFRAME (frame
) != selected_frame
)
2264 obj
= make_lispy_switch_frame (frame
);
2265 internal_last_event_frame
= frame
;
2269 /* If we didn't decide to make a switch-frame event, go ahead and
2270 return a mouse-motion event. */
2271 if (!NILP (x
) && NILP (obj
))
2272 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
2274 #endif /* HAVE_MOUSE */
2276 /* We were promised by the above while loop that there was
2277 something for us to read! */
2280 input_pending
= readable_events ();
2283 Vlast_event_frame
= internal_last_event_frame
;
2289 /* Process any events that are not user-visible,
2290 then return, without reading any user-visible events. */
2296 while ((perd
= find_active_event_queue ()) != NULL
)
2298 struct input_event
*event
;
2300 event
= ((perd
->kbd_fetch_ptr
< perd
->kbd_buffer
+ KBD_BUFFER_SIZE
)
2301 ? perd
->kbd_fetch_ptr
2302 : perd
->kbd_buffer
);
2304 last_event_timestamp
= event
->timestamp
;
2306 /* These two kinds of events get special handling
2307 and don't actually appear to the command loop. */
2308 if (event
->kind
== selection_request_event
)
2311 x_handle_selection_request (event
);
2312 perd
->kbd_fetch_ptr
= event
+ 1;
2314 /* We're getting selection request events, but we don't have
2320 else if (event
->kind
== selection_clear_event
)
2323 x_handle_selection_clear (event
);
2324 perd
->kbd_fetch_ptr
= event
+ 1;
2326 /* We're getting selection request events, but we don't have
2335 get_input_pending (&input_pending
);
2338 /* Caches for modify_event_symbol. */
2339 static Lisp_Object accent_key_syms
;
2340 static Lisp_Object system_key_syms
;
2341 static Lisp_Object func_key_syms
;
2342 static Lisp_Object mouse_syms
;
2344 Lisp_Object Vsystem_key_alist
;
2346 /* This is a list of keysym codes for special "accent" characters.
2347 It parallels lispy_accent_keys. */
2349 static int lispy_accent_codes
[] =
2351 #ifdef XK_dead_circumflex
2356 #ifdef XK_dead_grave
2361 #ifdef XK_dead_tilde
2366 #ifdef XK_dead_diaeresis
2371 #ifdef XK_dead_macron
2376 #ifdef XK_dead_degree
2381 #ifdef XK_dead_acute
2386 #ifdef XK_dead_cedilla
2391 #ifdef XK_dead_breve
2396 #ifdef XK_dead_ogonek
2401 #ifdef XK_dead_caron
2406 #ifdef XK_dead_doubleacute
2407 XK_dead_doubleacute
,
2411 #ifdef XK_dead_abovedot
2418 /* This is a list of Lisp names for special "accent" characters.
2419 It parallels lispy_accent_codes. */
2421 static char *lispy_accent_keys
[] =
2438 /* You'll notice that this table is arranged to be conveniently
2439 indexed by X Windows keysym values. */
2440 static char *lispy_function_keys
[] =
2442 /* X Keysym value */
2444 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00 */
2452 0, 0, 0, /* 0xff10 */
2454 0, 0, 0, 0, 0, 0, 0,
2457 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff20...2f */
2458 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff30...3f */
2459 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
2461 "home", /* 0xff50 */ /* IsCursorKey */
2472 "select", /* 0xff60 */ /* IsMiscFunctionKey */
2483 "break", /* 0xff6b */
2485 0, 0, 0, 0, 0, 0, 0, 0, "backtab", 0,
2487 0, 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff7f */
2488 "kp-space", /* 0xff80 */ /* IsKeypadKey */
2489 0, 0, 0, 0, 0, 0, 0, 0,
2490 "kp-tab", /* 0xff89 */
2492 "kp-enter", /* 0xff8d */
2494 "kp-f1", /* 0xff91 */
2498 "kp-home", /* 0xff95 */
2503 "kp-prior", /* kp-page-up */
2504 "kp-next", /* kp-page-down */
2510 0, 0, 0, 0, 0, 0, 0, 0, 0,
2511 "kp-multiply", /* 0xffaa */
2516 "kp-divide", /* 0xffaf */
2517 "kp-0", /* 0xffb0 */
2518 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
2521 "kp-equal", /* 0xffbd */
2522 "f1", /* 0xffbe */ /* IsFunctionKey */
2524 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
2525 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
2526 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
2527 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
2528 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
2529 0, 0, 0, 0, 0, 0, 0, 0,
2530 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
2531 0, 0, 0, 0, 0, 0, 0, "delete"
2534 static char *lispy_mouse_names
[] =
2536 "mouse-1", "mouse-2", "mouse-3", "mouse-4", "mouse-5"
2539 /* Scroll bar parts. */
2540 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
2542 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
2543 Lisp_Object
*scroll_bar_parts
[] = {
2544 &Qabove_handle
, &Qhandle
, &Qbelow_handle
2548 /* A vector, indexed by button number, giving the down-going location
2549 of currently depressed buttons, both scroll bar and non-scroll bar.
2551 The elements have the form
2552 (BUTTON-NUMBER MODIFIER-MASK . REST)
2553 where REST is the cdr of a position as it would be reported in the event.
2555 The make_lispy_event function stores positions here to tell the
2556 difference between click and drag events, and to store the starting
2557 location to be included in drag events. */
2559 static Lisp_Object button_down_location
;
2561 /* Information about the most recent up-going button event: Which
2562 button, what location, and what time. */
2564 static int last_mouse_button
;
2565 static int last_mouse_x
;
2566 static int last_mouse_y
;
2567 static unsigned long button_down_time
;
2569 /* The maximum time between clicks to make a double-click,
2570 or Qnil to disable double-click detection,
2571 or Qt for no time limit. */
2572 Lisp_Object Vdouble_click_time
;
2574 /* The number of clicks in this multiple-click. */
2576 int double_click_count
;
2578 #ifdef USE_X_TOOLKIT
2579 extern Lisp_Object
map_event_to_object ();
2580 #endif /* USE_X_TOOLKIT */
2582 /* Given a struct input_event, build the lisp event which represents
2583 it. If EVENT is 0, build a mouse movement event from the mouse
2584 movement buffer, which should have a movement event in it.
2586 Note that events must be passed to this function in the order they
2587 are received; this function stores the location of button presses
2588 in order to build drag events when the button is released. */
2591 make_lispy_event (event
)
2592 struct input_event
*event
;
2596 switch (SWITCH_ENUM_CAST (event
->kind
))
2598 /* A simple keystroke. */
2599 case ascii_keystroke
:
2601 Lisp_Object lispy_c
;
2602 int c
= event
->code
& 0377;
2603 /* Turn ASCII characters into control characters
2605 if (event
->modifiers
& ctrl_modifier
)
2606 c
= make_ctrl_char (c
);
2608 /* Add in the other modifier bits. We took care of ctrl_modifier
2609 just above, and the shift key was taken care of by the X code,
2610 and applied to control characters by make_ctrl_char. */
2611 c
|= (event
->modifiers
2612 & (meta_modifier
| alt_modifier
2613 | hyper_modifier
| super_modifier
));
2614 button_down_time
= 0;
2615 XSETFASTINT (lispy_c
, c
);
2619 /* A function key. The symbol may need to have modifier prefixes
2621 case non_ascii_keystroke
:
2622 button_down_time
= 0;
2624 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
2625 if (event
->code
== lispy_accent_codes
[i
])
2626 return modify_event_symbol (i
,
2628 Qfunction_key
, Qnil
,
2629 lispy_accent_keys
, &accent_key_syms
,
2630 (sizeof (lispy_accent_keys
)
2631 / sizeof (lispy_accent_keys
[0])));
2633 /* Handle system-specific keysyms. */
2634 if (event
->code
& (1 << 28))
2636 /* We need to use an alist rather than a vector as the cache
2637 since we can't make a vector long enuf. */
2638 if (NILP (system_key_syms
))
2639 system_key_syms
= Fcons (Qnil
, Qnil
);
2640 return modify_event_symbol (event
->code
& 0xffffff,
2642 Qfunction_key
, Vsystem_key_alist
,
2643 0, &system_key_syms
, 0xffffff);
2646 return modify_event_symbol (event
->code
- 0xff00,
2648 Qfunction_key
, Qnil
,
2649 lispy_function_keys
, &func_key_syms
,
2650 (sizeof (lispy_function_keys
)
2651 / sizeof (lispy_function_keys
[0])));
2654 #if defined (MULTI_FRAME) || defined (HAVE_MOUSE)
2655 /* A mouse click. Figure out where it is, decide whether it's
2656 a press, click or drag, and build the appropriate structure. */
2658 case scroll_bar_click
:
2660 int button
= event
->code
;
2662 Lisp_Object position
;
2663 Lisp_Object
*start_pos_ptr
;
2664 Lisp_Object start_pos
;
2666 if (button
< 0 || button
>= NUM_MOUSE_BUTTONS
)
2669 /* Build the position as appropriate for this mouse click. */
2670 if (event
->kind
== mouse_click
)
2673 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
2678 /* Ignore mouse events that were made on frame that
2679 have been deleted. */
2680 if (! FRAME_LIVE_P (f
))
2683 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
2684 &column
, &row
, 0, 1);
2686 #ifndef USE_X_TOOLKIT
2687 /* In the non-toolkit version, clicks on the menu bar
2688 are ordinary button events in the event buffer.
2689 Distinguish them, and invoke the menu.
2691 (In the toolkit version, the toolkit handles the menu bar
2692 and Emacs doesn't know about it until after the user
2693 makes a selection.) */
2694 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
))
2696 Lisp_Object items
, item
;
2700 /* Activate the menu bar on the down event. If the
2701 up event comes in before the menu code can deal with it,
2703 if (! (event
->modifiers
& down_modifier
))
2707 items
= FRAME_MENU_BAR_ITEMS (f
);
2708 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 3)
2710 Lisp_Object pos
, string
;
2711 string
= XVECTOR (items
)->contents
[i
+ 1];
2712 pos
= XVECTOR (items
)->contents
[i
+ 2];
2715 if (column
>= XINT (pos
)
2716 && column
< XINT (pos
) + XSTRING (string
)->size
)
2718 item
= XVECTOR (items
)->contents
[i
];
2724 = Fcons (event
->frame_or_window
,
2726 Fcons (Fcons (event
->x
, event
->y
),
2727 Fcons (make_number (event
->timestamp
),
2730 return Fcons (item
, Fcons (position
, Qnil
));
2732 #endif /* not USE_X_TOOLKIT */
2734 window
= window_from_coordinates (f
, column
, row
, &part
);
2736 if (!WINDOWP (window
))
2738 window
= event
->frame_or_window
;
2743 int pixcolumn
, pixrow
;
2744 column
-= XINT (XWINDOW (window
)->left
);
2745 row
-= XINT (XWINDOW (window
)->top
);
2746 glyph_to_pixel_coords (f
, column
, row
, &pixcolumn
, &pixrow
);
2747 XSETINT (event
->x
, pixcolumn
);
2748 XSETINT (event
->y
, pixrow
);
2753 posn
= Qvertical_line
;
2756 buffer_posn_from_coords (XWINDOW (window
),
2763 Fcons (Fcons (event
->x
, event
->y
),
2764 Fcons (make_number (event
->timestamp
),
2770 Lisp_Object portion_whole
;
2773 window
= event
->frame_or_window
;
2774 portion_whole
= Fcons (event
->x
, event
->y
);
2775 part
= *scroll_bar_parts
[(int) event
->part
];
2779 Fcons (Qvertical_scroll_bar
,
2780 Fcons (portion_whole
,
2781 Fcons (make_number (event
->timestamp
),
2782 Fcons (part
, Qnil
)))));
2785 start_pos_ptr
= &XVECTOR (button_down_location
)->contents
[button
];
2787 start_pos
= *start_pos_ptr
;
2788 *start_pos_ptr
= Qnil
;
2790 is_double
= (button
== last_mouse_button
2791 && XINT (event
->x
) == last_mouse_x
2792 && XINT (event
->y
) == last_mouse_y
2793 && button_down_time
!= 0
2794 && (EQ (Vdouble_click_time
, Qt
)
2795 || (INTEGERP (Vdouble_click_time
)
2796 && ((int)(event
->timestamp
- button_down_time
)
2797 < XINT (Vdouble_click_time
)))));
2798 last_mouse_button
= button
;
2799 last_mouse_x
= XINT (event
->x
);
2800 last_mouse_y
= XINT (event
->y
);
2802 /* If this is a button press, squirrel away the location, so
2803 we can decide later whether it was a click or a drag. */
2804 if (event
->modifiers
& down_modifier
)
2808 double_click_count
++;
2809 event
->modifiers
|= ((double_click_count
> 2)
2814 double_click_count
= 1;
2815 button_down_time
= event
->timestamp
;
2816 *start_pos_ptr
= Fcopy_alist (position
);
2819 /* Now we're releasing a button - check the co-ordinates to
2820 see if this was a click or a drag. */
2821 else if (event
->modifiers
& up_modifier
)
2823 /* If we did not see a down before this up,
2824 ignore the up. Probably this happened because
2825 the down event chose a menu item.
2826 It would be an annoyance to treat the release
2827 of the button that chose the menu item
2828 as a separate event. */
2830 if (!CONSP (start_pos
))
2833 event
->modifiers
&= ~up_modifier
;
2834 #if 0 /* Formerly we treated an up with no down as a click event. */
2835 if (!CONSP (start_pos
))
2836 event
->modifiers
|= click_modifier
;
2840 /* The third element of every position should be the (x,y)
2844 down
= Fnth (make_number (2), start_pos
);
2845 if (EQ (event
->x
, XCONS (down
)->car
)
2846 && EQ (event
->y
, XCONS (down
)->cdr
))
2848 event
->modifiers
|= click_modifier
;
2852 button_down_time
= 0;
2853 event
->modifiers
|= drag_modifier
;
2855 /* Don't check is_double; treat this as multiple
2856 if the down-event was multiple. */
2857 if (double_click_count
> 1)
2858 event
->modifiers
|= ((double_click_count
> 2)
2864 /* Every mouse event should either have the down_modifier or
2865 the up_modifier set. */
2869 /* Get the symbol we should use for the mouse click. */
2872 head
= modify_event_symbol (button
,
2875 lispy_mouse_names
, &mouse_syms
,
2876 (sizeof (lispy_mouse_names
)
2877 / sizeof (lispy_mouse_names
[0])));
2878 if (event
->modifiers
& drag_modifier
)
2883 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
2886 Fcons (make_number (double_click_count
),
2894 #endif /* MULTI_FRAME or HAVE_MOUSE */
2896 /* The 'kind' field of the event is something we don't recognize. */
2902 #if defined (MULTI_FRAME) || defined (HAVE_MOUSE)
2905 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
2907 Lisp_Object bar_window
;
2908 enum scroll_bar_part part
;
2913 /* Is it a scroll bar movement? */
2914 if (frame
&& ! NILP (bar_window
))
2916 Lisp_Object part_sym
;
2918 part_sym
= *scroll_bar_parts
[(int) part
];
2919 return Fcons (Qscroll_bar_movement
,
2920 (Fcons (Fcons (bar_window
,
2921 Fcons (Qvertical_scroll_bar
,
2922 Fcons (Fcons (x
, y
),
2923 Fcons (make_number (time
),
2929 /* Or is it an ordinary mouse movement? */
2931 #endif /* MULTI_FRAME */
2944 /* It's in a frame; which window on that frame? */
2945 pixel_to_glyph_coords (frame
, XINT (x
), XINT (y
), &column
, &row
, 0, 1);
2946 window
= window_from_coordinates (frame
, column
, row
, &area
);
2951 if (WINDOWP (window
))
2953 int pixcolumn
, pixrow
;
2954 column
-= XINT (XWINDOW (window
)->left
);
2955 row
-= XINT (XWINDOW (window
)->top
);
2956 glyph_to_pixel_coords (frame
, column
, row
, &pixcolumn
, &pixrow
);
2957 XSETINT (x
, pixcolumn
);
2958 XSETINT (y
, pixrow
);
2963 posn
= Qvertical_line
;
2966 buffer_posn_from_coords (XWINDOW (window
), column
, row
));
2969 else if (frame
!= 0)
2971 XSETFRAME (window
, frame
);
2983 return Fcons (Qmouse_movement
,
2984 Fcons (Fcons (window
,
2986 Fcons (Fcons (x
, y
),
2987 Fcons (make_number (time
),
2993 #endif /* neither MULTI_FRAME nor HAVE_MOUSE */
2995 /* Construct a switch frame event. */
2997 make_lispy_switch_frame (frame
)
3000 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
3003 /* Manipulating modifiers. */
3005 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
3007 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
3008 SYMBOL's name of the end of the modifiers; the string from this
3009 position is the unmodified symbol name.
3011 This doesn't use any caches. */
3013 parse_modifiers_uncached (symbol
, modifier_end
)
3017 struct Lisp_String
*name
;
3021 CHECK_SYMBOL (symbol
, 1);
3024 name
= XSYMBOL (symbol
)->name
;
3027 for (i
= 0; i
+2 <= name
->size
; )
3028 switch (name
->data
[i
])
3030 #define SINGLE_LETTER_MOD(bit) \
3031 if (name->data[i+1] != '-') \
3032 goto no_more_modifiers; \
3037 SINGLE_LETTER_MOD (alt_modifier
);
3041 SINGLE_LETTER_MOD (ctrl_modifier
);
3045 SINGLE_LETTER_MOD (hyper_modifier
);
3049 SINGLE_LETTER_MOD (meta_modifier
);
3053 SINGLE_LETTER_MOD (shift_modifier
);
3057 SINGLE_LETTER_MOD (super_modifier
);
3061 if (i
+ 5 > name
->size
)
3062 goto no_more_modifiers
;
3063 if (! strncmp (name
->data
+ i
, "drag-", 5))
3065 modifiers
|= drag_modifier
;
3068 else if (! strncmp (name
->data
+ i
, "down-", 5))
3070 modifiers
|= down_modifier
;
3073 else if (i
+ 7 <= name
->size
3074 && ! strncmp (name
->data
+ i
, "double-", 7))
3076 modifiers
|= double_modifier
;
3080 goto no_more_modifiers
;
3084 if (i
+ 7 > name
->size
)
3085 goto no_more_modifiers
;
3086 if (! strncmp (name
->data
+ i
, "triple-", 7))
3088 modifiers
|= triple_modifier
;
3092 goto no_more_modifiers
;
3096 goto no_more_modifiers
;
3098 #undef SINGLE_LETTER_MOD
3102 /* Should we include the `click' modifier? */
3103 if (! (modifiers
& (down_modifier
| drag_modifier
3104 | double_modifier
| triple_modifier
))
3105 && i
+ 7 == name
->size
3106 && strncmp (name
->data
+ i
, "mouse-", 6) == 0
3107 && ('0' <= name
->data
[i
+ 6] && name
->data
[i
+ 6] <= '9'))
3108 modifiers
|= click_modifier
;
3117 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
3118 prepended to the string BASE[0..BASE_LEN-1].
3119 This doesn't use any caches. */
3121 apply_modifiers_uncached (modifiers
, base
, base_len
)
3126 /* Since BASE could contain nulls, we can't use intern here; we have
3127 to use Fintern, which expects a genuine Lisp_String, and keeps a
3130 (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
3136 /* Only the event queue may use the `up' modifier; it should always
3137 be turned into a click or drag event before presented to lisp code. */
3138 if (modifiers
& up_modifier
)
3141 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
3142 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
3143 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
3144 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
3145 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
3146 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
3147 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
3148 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
3149 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
3150 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
3151 /* The click modifier is denoted by the absence of other modifiers. */
3155 mod_len
= p
- new_mods
;
3159 Lisp_Object new_name
;
3161 new_name
= make_uninit_string (mod_len
+ base_len
);
3162 bcopy (new_mods
, XSTRING (new_name
)->data
, mod_len
);
3163 bcopy (base
, XSTRING (new_name
)->data
+ mod_len
, base_len
);
3165 return Fintern (new_name
, Qnil
);
3170 static char *modifier_names
[] =
3172 "up", "down", "drag", "click", "double", "triple", 0, 0,
3173 0, 0, 0, 0, 0, 0, 0, 0,
3174 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
3176 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
3178 static Lisp_Object modifier_symbols
;
3180 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
3182 lispy_modifier_list (modifiers
)
3185 Lisp_Object modifier_list
;
3188 modifier_list
= Qnil
;
3189 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
3190 if (modifiers
& (1<<i
))
3191 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
3194 return modifier_list
;
3198 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
3199 where UNMODIFIED is the unmodified form of SYMBOL,
3200 MASK is the set of modifiers present in SYMBOL's name.
3201 This is similar to parse_modifiers_uncached, but uses the cache in
3202 SYMBOL's Qevent_symbol_element_mask property, and maintains the
3203 Qevent_symbol_elements property. */
3205 parse_modifiers (symbol
)
3208 Lisp_Object elements
;
3210 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
3211 if (CONSP (elements
))
3216 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
3217 Lisp_Object unmodified
;
3220 unmodified
= Fintern (make_string (XSYMBOL (symbol
)->name
->data
+ end
,
3221 XSYMBOL (symbol
)->name
->size
- end
),
3224 if (modifiers
& ~((1<<VALBITS
) - 1))
3226 XSETFASTINT (mask
, modifiers
);
3227 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
3229 /* Cache the parsing results on SYMBOL. */
3230 Fput (symbol
, Qevent_symbol_element_mask
,
3232 Fput (symbol
, Qevent_symbol_elements
,
3233 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
3235 /* Since we know that SYMBOL is modifiers applied to unmodified,
3236 it would be nice to put that in unmodified's cache.
3237 But we can't, since we're not sure that parse_modifiers is
3244 /* Apply the modifiers MODIFIERS to the symbol BASE.
3245 BASE must be unmodified.
3247 This is like apply_modifiers_uncached, but uses BASE's
3248 Qmodifier_cache property, if present. It also builds
3249 Qevent_symbol_elements properties, since it has that info anyway.
3251 apply_modifiers copies the value of BASE's Qevent_kind property to
3252 the modified symbol. */
3254 apply_modifiers (modifiers
, base
)
3258 Lisp_Object cache
, index
, entry
, new_symbol
;
3260 /* Mask out upper bits. We don't know where this value's been. */
3261 modifiers
&= (1<<VALBITS
) - 1;
3263 /* The click modifier never figures into cache indices. */
3264 cache
= Fget (base
, Qmodifier_cache
);
3265 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
3266 entry
= assq_no_quit (index
, cache
);
3269 new_symbol
= XCONS (entry
)->cdr
;
3272 /* We have to create the symbol ourselves. */
3273 new_symbol
= apply_modifiers_uncached (modifiers
,
3274 XSYMBOL (base
)->name
->data
,
3275 XSYMBOL (base
)->name
->size
);
3277 /* Add the new symbol to the base's cache. */
3278 entry
= Fcons (index
, new_symbol
);
3279 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
3281 /* We have the parsing info now for free, so add it to the caches. */
3282 XSETFASTINT (index
, modifiers
);
3283 Fput (new_symbol
, Qevent_symbol_element_mask
,
3284 Fcons (base
, Fcons (index
, Qnil
)));
3285 Fput (new_symbol
, Qevent_symbol_elements
,
3286 Fcons (base
, lispy_modifier_list (modifiers
)));
3289 /* Make sure this symbol is of the same kind as BASE.
3291 You'd think we could just set this once and for all when we
3292 intern the symbol above, but reorder_modifiers may call us when
3293 BASE's property isn't set right; we can't assume that just
3294 because it has a Qmodifier_cache property it must have its
3295 Qevent_kind set right as well. */
3296 if (NILP (Fget (new_symbol
, Qevent_kind
)))
3300 kind
= Fget (base
, Qevent_kind
);
3302 Fput (new_symbol
, Qevent_kind
, kind
);
3309 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
3310 return a symbol with the modifiers placed in the canonical order.
3311 Canonical order is alphabetical, except for down and drag, which
3312 always come last. The 'click' modifier is never written out.
3314 Fdefine_key calls this to make sure that (for example) C-M-foo
3315 and M-C-foo end up being equivalent in the keymap. */
3318 reorder_modifiers (symbol
)
3321 /* It's hopefully okay to write the code this way, since everything
3322 will soon be in caches, and no consing will be done at all. */
3325 parsed
= parse_modifiers (symbol
);
3326 return apply_modifiers (XCONS (XCONS (parsed
)->cdr
)->car
,
3327 XCONS (parsed
)->car
);
3331 /* For handling events, we often want to produce a symbol whose name
3332 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
3333 to some base, like the name of a function key or mouse button.
3334 modify_event_symbol produces symbols of this sort.
3336 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
3337 is the name of the i'th symbol. TABLE_SIZE is the number of elements
3340 Alternatively, NAME_ALIST is an alist mapping codes into symbol names.
3341 NAME_ALIST is used if it is non-nil; otherwise NAME_TABLE is used.
3343 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
3344 persist between calls to modify_event_symbol that it can use to
3345 store a cache of the symbols it's generated for this NAME_TABLE
3346 before. The object stored there may be a vector or an alist.
3348 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
3350 MODIFIERS is a set of modifier bits (as given in struct input_events)
3351 whose prefixes should be applied to the symbol name.
3353 SYMBOL_KIND is the value to be placed in the event_kind property of
3354 the returned symbol.
3356 The symbols we create are supposed to have an
3357 `event-symbol-elements' property, which lists the modifiers present
3358 in the symbol's name. */
3361 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist
,
3362 name_table
, symbol_table
, table_size
)
3365 Lisp_Object symbol_kind
;
3366 Lisp_Object name_alist
;
3368 Lisp_Object
*symbol_table
;
3372 Lisp_Object symbol_int
;
3374 XSETINT (symbol_int
, symbol_num
);
3376 /* Is this a request for a valid symbol? */
3377 if (symbol_num
< 0 || symbol_num
>= table_size
)
3380 if (CONSP (*symbol_table
))
3381 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
3383 /* If *symbol_table doesn't seem to be initialized properly, fix that.
3384 *symbol_table should be a lisp vector TABLE_SIZE elements long,
3385 where the Nth element is the symbol for NAME_TABLE[N], or nil if
3386 we've never used that symbol before. */
3389 if (! VECTORP (*symbol_table
)
3390 || XVECTOR (*symbol_table
)->size
!= table_size
)
3394 XSETFASTINT (size
, table_size
);
3395 *symbol_table
= Fmake_vector (size
, Qnil
);
3398 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
3401 /* Have we already used this symbol before? */
3404 /* No; let's create it. */
3405 if (!NILP (name_alist
))
3406 value
= Fcdr_safe (Fassq (symbol_int
, name_alist
));
3407 else if (name_table
[symbol_num
])
3408 value
= intern (name_table
[symbol_num
]);
3413 sprintf (buf
, "key-%d", symbol_num
);
3414 value
= intern (buf
);
3417 if (CONSP (*symbol_table
))
3418 *symbol_table
= Fcons (value
, *symbol_table
);
3420 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
3422 /* Fill in the cache entries for this symbol; this also
3423 builds the Qevent_symbol_elements property, which the user
3425 apply_modifiers (modifiers
& click_modifier
, value
);
3426 Fput (value
, Qevent_kind
, symbol_kind
);
3429 /* Apply modifiers to that symbol. */
3430 return apply_modifiers (modifiers
, value
);
3434 /* Store into *addr a value nonzero if terminal input chars are available.
3435 Serves the purpose of ioctl (0, FIONREAD, addr)
3436 but works even if FIONREAD does not exist.
3437 (In fact, this may actually read some input.) */
3440 get_input_pending (addr
)
3443 /* First of all, have we already counted some input? */
3444 *addr
= !NILP (Vquit_flag
) || readable_events ();
3446 /* If input is being read as it arrives, and we have none, there is none. */
3447 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
3450 /* Try to read some input and see how much we get. */
3452 *addr
= !NILP (Vquit_flag
) || readable_events ();
3455 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
3458 gobble_input (expected
)
3463 if (interrupt_input
)
3466 mask
= sigblockx (SIGIO
);
3467 read_avail_input (expected
);
3471 #ifdef POLL_FOR_INPUT
3472 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
3475 mask
= sigblockx (SIGALRM
);
3476 read_avail_input (expected
);
3482 read_avail_input (expected
);
3486 /* Put a buffer_switch_event in the buffer
3487 so that read_key_sequence will notice the new current buffer. */
3489 record_asynch_buffer_change ()
3491 struct input_event event
;
3494 event
.kind
= buffer_switch_event
;
3495 event
.frame_or_window
= Qnil
;
3498 /* We don't need a buffer-switch event unless Emacs is waiting for input.
3499 The purpose of the event is to make read_key_sequence look up the
3500 keymaps again. If we aren't in read_key_sequence, we don't need one,
3501 and the event could cause trouble by messing up (input-pending-p). */
3502 tem
= Fwaiting_for_user_input_p ();
3506 /* We never need these events if we have no asynchronous subprocesses. */
3510 /* Make sure no interrupt happens while storing the event. */
3512 if (interrupt_input
)
3515 mask
= sigblockx (SIGIO
);
3516 kbd_buffer_store_event (&event
);
3523 kbd_buffer_store_event (&event
);
3530 /* Read any terminal input already buffered up by the system
3531 into the kbd_buffer, but do not wait.
3533 EXPECTED should be nonzero if the caller knows there is some input.
3535 Except on VMS, all input is read by this function.
3536 If interrupt_input is nonzero, this function MUST be called
3537 only when SIGIO is blocked.
3539 Returns the number of keyboard chars read, or -1 meaning
3540 this is a bad time to try to read input. */
3543 read_avail_input (expected
)
3546 struct input_event buf
[KBD_BUFFER_SIZE
];
3550 if (read_socket_hook
)
3551 /* No need for FIONREAD or fcntl; just say don't wait. */
3552 nread
= (*read_socket_hook
) (input_fd
, buf
, KBD_BUFFER_SIZE
,
3553 expected
, expected
);
3556 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
3557 the kbd_buffer can really hold. That may prevent loss
3558 of characters on some systems when input is stuffed at us. */
3559 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
3562 /* Determine how many characters we should *try* to read. */
3565 #else /* not WINDOWSNT */
3567 n_to_read
= dos_keysns ();
3570 #else /* not MSDOS */
3572 /* Find out how much input is available. */
3573 if (ioctl (input_fd
, FIONREAD
, &n_to_read
) < 0)
3574 /* Formerly simply reported no input, but that sometimes led to
3575 a failure of Emacs to terminate.
3576 SIGHUP seems appropriate if we can't reach the terminal. */
3577 /* ??? Is it really right to send the signal just to this process
3578 rather than to the whole process group?
3579 Perhaps on systems with FIONREAD Emacs is alone in its group. */
3580 kill (getpid (), SIGHUP
);
3583 if (n_to_read
> sizeof cbuf
)
3584 n_to_read
= sizeof cbuf
;
3585 #else /* no FIONREAD */
3586 #if defined(USG) || defined(DGUX)
3587 /* Read some input if available, but don't wait. */
3588 n_to_read
= sizeof cbuf
;
3589 fcntl (input_fd
, F_SETFL
, O_NDELAY
);
3594 #endif /* not MSDOS */
3595 #endif /* not WINDOWSNT */
3597 /* Now read; for one reason or another, this will not block.
3598 NREAD is set to the number of chars read. */
3602 cbuf
[0] = dos_keyread();
3605 nread
= read (input_fd
, cbuf
, n_to_read
);
3607 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
3608 /* The kernel sometimes fails to deliver SIGHUP for ptys.
3609 This looks incorrect, but it isn't, because _BSD causes
3610 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
3611 and that causes a value other than 0 when there is no input. */
3617 /* We used to retry the read if it was interrupted.
3618 But this does the wrong thing when O_NDELAY causes
3619 an EAGAIN error. Does anybody know of a situation
3620 where a retry is actually needed? */
3622 nread
< 0 && (errno
== EAGAIN
3636 #if defined (USG) || defined (DGUX)
3637 fcntl (input_fd
, F_SETFL
, 0);
3638 #endif /* USG or DGUX */
3639 #endif /* no FIONREAD */
3640 for (i
= 0; i
< nread
; i
++)
3642 buf
[i
].kind
= ascii_keystroke
;
3643 buf
[i
].modifiers
= 0;
3644 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
3645 buf
[i
].modifiers
= meta_modifier
;
3649 buf
[i
].code
= cbuf
[i
];
3651 XSETFRAME (buf
[i
].frame_or_window
, selected_frame
);
3653 buf
[i
].frame_or_window
= Qnil
;
3658 /* Scan the chars for C-g and store them in kbd_buffer. */
3659 for (i
= 0; i
< nread
; i
++)
3661 kbd_buffer_store_event (&buf
[i
]);
3662 /* Don't look at input that follows a C-g too closely.
3663 This reduces lossage due to autorepeat on C-g. */
3664 if (buf
[i
].kind
== ascii_keystroke
3665 && buf
[i
].code
== quit_char
)
3671 #endif /* not VMS */
3673 #ifdef SIGIO /* for entire page */
3674 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3677 input_available_signal (signo
)
3680 /* Must preserve main program's value of errno. */
3681 int old_errno
= errno
;
3683 extern int select_alarmed
;
3687 /* USG systems forget handlers when they are used;
3688 must reestablish each time */
3689 signal (signo
, input_available_signal
);
3696 if (input_available_clear_time
)
3697 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
3702 nread
= read_avail_input (1);
3703 /* -1 means it's not ok to read the input now.
3704 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
3705 0 means there was no keyboard input available. */
3710 select_alarmed
= 1; /* Force the select emulator back to life */
3721 /* Send ourselves a SIGIO.
3723 This function exists so that the UNBLOCK_INPUT macro in
3724 blockinput.h can have some way to take care of input we put off
3725 dealing with, without assuming that every file which uses
3726 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
3728 reinvoke_input_signal ()
3737 /* Return the prompt-string of a sparse keymap.
3738 This is the first element which is a string.
3739 Return nil if there is none. */
3747 register Lisp_Object tem
;
3756 static void menu_bar_item ();
3757 static void menu_bar_one_keymap ();
3759 /* These variables hold the vector under construction within
3760 menu_bar_items and its subroutines, and the current index
3761 for storing into that vector. */
3762 static Lisp_Object menu_bar_items_vector
;
3763 static int menu_bar_items_index
;
3765 /* Return a vector of menu items for a menu bar, appropriate
3766 to the current buffer. Each item has three elements in the vector:
3769 OLD is an old vector we can optionally reuse, or nil. */
3772 menu_bar_items (old
)
3775 /* The number of keymaps we're scanning right now, and the number of
3776 keymaps we have allocated space for. */
3779 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
3780 in the current keymaps, or nil where it is not a prefix. */
3783 Lisp_Object def
, tem
, tail
;
3792 struct gcpro gcpro1
;
3794 /* In order to build the menus, we need to call the keymap
3795 accessors. They all call QUIT. But this function is called
3796 during redisplay, during which a quit is fatal. So inhibit
3797 quitting while building the menus.
3798 We do this instead of specbind because (1) errors will clear it anyway
3799 and (2) this avoids risk of specpdl overflow. */
3800 oquit
= Vinhibit_quit
;
3804 menu_bar_items_vector
= old
;
3806 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
3807 menu_bar_items_index
= 0;
3809 GCPRO1 (menu_bar_items_vector
);
3811 /* Build our list of keymaps.
3812 If we recognize a function key and replace its escape sequence in
3813 keybuf with its symbol, or if the sequence starts with a mouse
3814 click and we need to switch buffers, we jump back here to rebuild
3815 the initial keymaps from the current buffer. */
3819 /* Should overriding-local-map apply, here? */
3820 if (!NILP (Voverriding_local_map_menu_flag
))
3822 if (NILP (Voverriding_local_map
))
3824 /* Yes, and it is nil. Use just global map. */
3826 maps
= (Lisp_Object
*) alloca (nmaps
* sizeof (maps
[0]));
3830 /* Yes, and it is non-nil. Use it and the global map. */
3832 maps
= (Lisp_Object
*) alloca (nmaps
* sizeof (maps
[0]));
3833 maps
[0] = Voverriding_local_map
;
3838 /* No, so use major and minor mode keymaps. */
3839 nmaps
= current_minor_maps (0, &tmaps
) + 2;
3840 maps
= (Lisp_Object
*) alloca (nmaps
* sizeof (maps
[0]));
3841 bcopy (tmaps
, maps
, (nmaps
- 2) * sizeof (maps
[0]));
3842 #ifdef USE_TEXT_PROPERTIES
3843 maps
[nmaps
-2] = get_local_map (PT
, current_buffer
);
3845 maps
[nmaps
-2] = current_buffer
->keymap
;
3848 maps
[nmaps
-1] = current_global_map
;
3851 /* Look up in each map the dummy prefix key `menu-bar'. */
3855 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
3857 if (! NILP (maps
[mapno
]))
3858 def
= get_keyelt (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0));
3862 tem
= Fkeymapp (def
);
3864 menu_bar_one_keymap (def
);
3867 /* Move to the end those items that should be at the end. */
3869 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
3872 int end
= menu_bar_items_index
;
3874 for (i
= 0; i
< end
; i
+= 3)
3875 if (EQ (XCONS (tail
)->car
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
3877 Lisp_Object tem0
, tem1
, tem2
;
3878 /* Move the item at index I to the end,
3879 shifting all the others forward. */
3880 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
3881 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
3882 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
3884 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3],
3885 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
3886 (end
- i
- 3) * sizeof (Lisp_Object
));
3887 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem0
;
3888 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem1
;
3889 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem2
;
3894 /* Add nil, nil, nil at the end. */
3895 i
= menu_bar_items_index
;
3896 if (i
+ 3 > XVECTOR (menu_bar_items_vector
)->size
)
3899 int newsize
= 2 * i
;
3900 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
3901 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
3902 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
3903 menu_bar_items_vector
= tem
;
3905 /* Add this item. */
3906 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
3907 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
3908 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
3909 menu_bar_items_index
= i
;
3911 Vinhibit_quit
= oquit
;
3913 return menu_bar_items_vector
;
3916 /* Scan one map KEYMAP, accumulating any menu items it defines
3917 in menu_bar_items_vector. */
3920 menu_bar_one_keymap (keymap
)
3923 Lisp_Object tail
, item
, key
, binding
, item_string
, table
;
3925 /* Loop over all keymap entries that have menu strings. */
3926 for (tail
= keymap
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
3928 item
= XCONS (tail
)->car
;
3931 key
= XCONS (item
)->car
;
3932 binding
= XCONS (item
)->cdr
;
3933 if (CONSP (binding
))
3935 item_string
= XCONS (binding
)->car
;
3936 if (STRINGP (item_string
))
3937 menu_bar_item (key
, item_string
, Fcdr (binding
));
3939 else if (EQ (binding
, Qundefined
))
3940 menu_bar_item (key
, Qnil
, binding
);
3942 else if (VECTORP (item
))
3944 /* Loop over the char values represented in the vector. */
3945 int len
= XVECTOR (item
)->size
;
3947 for (c
= 0; c
< len
; c
++)
3949 Lisp_Object character
;
3950 XSETFASTINT (character
, c
);
3951 binding
= XVECTOR (item
)->contents
[c
];
3952 if (CONSP (binding
))
3954 item_string
= XCONS (binding
)->car
;
3955 if (STRINGP (item_string
))
3956 menu_bar_item (key
, item_string
, Fcdr (binding
));
3958 else if (EQ (binding
, Qundefined
))
3959 menu_bar_item (key
, Qnil
, binding
);
3965 /* This is used as the handler when calling internal_condition_case_1. */
3968 menu_bar_item_1 (arg
)
3974 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
3975 If there's already an item for KEY, add this DEF to it. */
3978 menu_bar_item (key
, item_string
, def
)
3979 Lisp_Object key
, item_string
, def
;
3982 Lisp_Object enabled
;
3985 if (EQ (def
, Qundefined
))
3987 /* If a map has an explicit `undefined' as definition,
3988 discard any previously made menu bar item. */
3990 for (i
= 0; i
< menu_bar_items_index
; i
+= 3)
3991 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
3993 if (menu_bar_items_index
> i
+ 3)
3994 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3],
3995 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
3996 (menu_bar_items_index
- i
- 3) * sizeof (Lisp_Object
));
3997 menu_bar_items_index
-= 3;
4001 /* If there's no definition for this key yet,
4002 just ignore `undefined'. */
4006 /* See if this entry is enabled. */
4011 /* No property, or nil, means enable.
4012 Otherwise, enable if value is not nil. */
4013 tem
= Fget (def
, Qmenu_enable
);
4015 /* (condition-case nil (eval tem)
4017 enabled
= internal_condition_case_1 (Feval
, tem
, Qerror
,
4021 /* Ignore this item if it's not enabled. */
4025 /* Find any existing item for this KEY. */
4026 for (i
= 0; i
< menu_bar_items_index
; i
+= 3)
4027 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
4030 /* If we did not find this KEY, add it at the end. */
4031 if (i
== menu_bar_items_index
)
4033 /* If vector is too small, get a bigger one. */
4034 if (i
+ 3 > XVECTOR (menu_bar_items_vector
)->size
)
4037 int newsize
= 2 * i
;
4038 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
4039 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
4040 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
4041 menu_bar_items_vector
= tem
;
4043 /* Add this item. */
4044 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
4045 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = item_string
;
4046 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (def
, Qnil
);
4047 menu_bar_items_index
= i
;
4049 /* We did find an item for this KEY. Add DEF to its list of maps. */
4053 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
4054 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = Fcons (def
, old
);
4058 /* Read a character using menus based on maps in the array MAPS.
4059 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
4060 Return t if we displayed a menu but the user rejected it.
4062 PREV_EVENT is the previous input event, or nil if we are reading
4063 the first event of a key sequence.
4065 If USED_MOUSE_MENU is non-zero, then we set *USED_MOUSE_MENU to 1
4066 if we used a mouse menu to read the input, or zero otherwise. If
4067 USED_MOUSE_MENU is zero, *USED_MOUSE_MENU is left alone.
4069 The prompting is done based on the prompt-string of the map
4070 and the strings associated with various map elements.
4072 This can be done with X menus or with menus put in the minibuf.
4073 These are done in different ways, depending on how the input will be read.
4074 Menus using X are done after auto-saving in read-char, getting the input
4075 event from Fx_popup_menu; menus using the minibuf use read_char recursively
4076 and do auto-saving in the inner call of read_char. */
4079 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
4082 Lisp_Object prev_event
;
4083 int *used_mouse_menu
;
4086 register Lisp_Object name
;
4087 Lisp_Object rest
, vector
;
4089 if (used_mouse_menu
)
4090 *used_mouse_menu
= 0;
4092 /* Use local over global Menu maps */
4094 if (! menu_prompting
)
4097 /* Optionally disregard all but the global map. */
4098 if (inhibit_local_menu_bar_menus
)
4100 maps
+= (nmaps
- 1);
4104 /* Get the menu name from the first map that has one (a prompt string). */
4105 for (mapno
= 0; mapno
< nmaps
; mapno
++)
4107 name
= map_prompt (maps
[mapno
]);
4112 /* If we don't have any menus, just read a character normally. */
4116 #if (defined (HAVE_X_WINDOWS) && defined (HAVE_X_MENU)) || defined (MSDOS)
4117 /* If we got to this point via a mouse click,
4118 use a real menu for mouse selection. */
4119 if (EVENT_HAS_PARAMETERS (prev_event
))
4121 /* Display the menu and get the selection. */
4122 Lisp_Object
*realmaps
4123 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
4127 /* Use the maps that are not nil. */
4128 for (mapno
= 0; mapno
< nmaps
; mapno
++)
4129 if (!NILP (maps
[mapno
]))
4130 realmaps
[nmaps1
++] = maps
[mapno
];
4132 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
4135 /* If we got more than one event, put all but the first
4136 onto this list to be read later.
4137 Return just the first event now. */
4138 Vunread_command_events
4139 = nconc2 (XCONS (value
)->cdr
, Vunread_command_events
);
4140 value
= XCONS (value
)->car
;
4142 else if (NILP (value
))
4144 if (used_mouse_menu
)
4145 *used_mouse_menu
= 1;
4148 #endif /* (HAVE_X_WINDOWS && HAVE_X_MENU) || MSDOS */
4153 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
4159 register Lisp_Object name
;
4161 int width
= FRAME_WIDTH (selected_frame
) - 4;
4162 char *menu
= (char *) alloca (width
+ 4);
4165 Lisp_Object rest
, vector
;
4167 if (! menu_prompting
)
4170 /* Get the menu name from the first map that has one (a prompt string). */
4171 for (mapno
= 0; mapno
< nmaps
; mapno
++)
4173 name
= map_prompt (maps
[mapno
]);
4178 /* If we don't have any menus, just read a character normally. */
4182 /* Prompt string always starts with map's prompt, and a space. */
4183 strcpy (menu
, XSTRING (name
)->data
);
4184 nlength
= XSTRING (name
)->size
;
4185 menu
[nlength
++] = ':';
4186 menu
[nlength
++] = ' ';
4189 /* Start prompting at start of first map. */
4193 /* Present the documented bindings, a line at a time. */
4200 int orig_defn_macro
;
4202 /* Loop over elements of map. */
4207 /* If reached end of map, start at beginning of next map. */
4211 /* At end of last map, wrap around to first map if just starting,
4212 or end this line if already have something on it. */
4216 if (notfirst
|| nobindings
) break;
4221 /* Look at the next element of the map. */
4223 elt
= XVECTOR (vector
)->contents
[idx
];
4225 elt
= Fcar_safe (rest
);
4227 if (idx
< 0 && VECTORP (elt
))
4229 /* If we found a dense table in the keymap,
4230 advanced past it, but start scanning its contents. */
4231 rest
= Fcdr_safe (rest
);
4237 /* An ordinary element. */
4239 s
= Fcar_safe (Fcdr_safe (elt
)); /* alist */
4241 s
= Fcar_safe(elt
); /* vector */
4243 /* Ignore the element if it has no prompt string. */
4245 /* If we have room for the prompt string, add it to this line.
4246 If this is the first on the line, always add it. */
4247 else if (XSTRING (s
)->size
+ i
+ 2 < width
4252 /* Punctuate between strings. */
4255 strcpy (menu
+ i
, ", ");
4261 /* Add as much of string as fits. */
4262 thiswidth
= XSTRING (s
)->size
;
4263 if (thiswidth
+ i
> width
)
4264 thiswidth
= width
- i
;
4265 bcopy (XSTRING (s
)->data
, menu
+ i
, thiswidth
);
4271 /* If this element does not fit, end the line now,
4272 and save the element for the next line. */
4273 strcpy (menu
+ i
, "...");
4277 /* Move past this element. */
4278 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
4279 /* Handle reaching end of dense table. */
4284 rest
= Fcdr_safe (rest
);
4288 /* Prompt with that and read response. */
4291 /* Make believe its not a keyboard macro in case the help char
4292 is pressed. Help characters are not recorded because menu prompting
4293 is not used on replay.
4295 orig_defn_macro
= defining_kbd_macro
;
4296 defining_kbd_macro
= 0 ;
4298 obj
= read_char (commandflag
, 0, 0, Qnil
, 0);
4299 while (BUFFERP (obj
));
4300 defining_kbd_macro
= orig_defn_macro
;
4302 if (!INTEGERP (obj
))
4307 if (! EQ (obj
, menu_prompt_more_char
)
4308 && (!INTEGERP (menu_prompt_more_char
)
4309 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
4311 if ( defining_kbd_macro
)
4312 store_kbd_macro_char(obj
) ;
4315 /* Help char - go round again */
4319 /* Reading key sequences. */
4321 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
4322 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
4323 keymap, or nil otherwise. Return the index of the first keymap in
4324 which KEY has any binding, or NMAPS if no map has a binding.
4326 If KEY is a meta ASCII character, treat it like meta-prefix-char
4327 followed by the corresponding non-meta character. Keymaps in
4328 CURRENT with non-prefix bindings for meta-prefix-char become nil in
4331 If KEY has no bindings in any of the CURRENT maps, NEXT is left
4334 NEXT may == CURRENT. */
4337 follow_key (key
, nmaps
, current
, defs
, next
)
4339 Lisp_Object
*current
, *defs
, *next
;
4342 int i
, first_binding
;
4344 /* If KEY is a meta ASCII character, treat it like meta-prefix-char
4345 followed by the corresponding non-meta character. */
4346 if (INTEGERP (key
) && (XINT (key
) & CHAR_META
))
4348 for (i
= 0; i
< nmaps
; i
++)
4349 if (! NILP (current
[i
]))
4352 get_keyelt (access_keymap (current
[i
], meta_prefix_char
, 1, 0));
4354 /* Note that since we pass the resulting bindings through
4355 get_keymap_1, non-prefix bindings for meta-prefix-char
4357 next
[i
] = get_keymap_1 (next
[i
], 0, 1);
4363 XSETINT (key
, XFASTINT (key
) & ~CHAR_META
);
4366 first_binding
= nmaps
;
4367 for (i
= nmaps
- 1; i
>= 0; i
--)
4369 if (! NILP (current
[i
]))
4371 defs
[i
] = get_keyelt (access_keymap (current
[i
], key
, 1, 0));
4372 if (! NILP (defs
[i
]))
4379 /* Given the set of bindings we've found, produce the next set of maps. */
4380 if (first_binding
< nmaps
)
4381 for (i
= 0; i
< nmaps
; i
++)
4382 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap_1 (defs
[i
], 0, 1);
4384 return first_binding
;
4387 /* Read a sequence of keys that ends with a non prefix character,
4388 storing it in KEYBUF, a buffer of size BUFSIZE.
4390 Return the length of the key sequence stored.
4391 Return -1 if the user rejected a command menu.
4393 Echo starting immediately unless `prompt' is 0.
4395 Where a key sequence ends depends on the currently active keymaps.
4396 These include any minor mode keymaps active in the current buffer,
4397 the current buffer's local map, and the global map.
4399 If a key sequence has no other bindings, we check Vfunction_key_map
4400 to see if some trailing subsequence might be the beginning of a
4401 function key's sequence. If so, we try to read the whole function
4402 key, and substitute its symbolic name into the key sequence.
4404 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
4405 `double-' events into similar click events, if that would make them
4406 bound. We try to turn `triple-' events first into `double-' events,
4409 If we get a mouse click in a mode line, vertical divider, or other
4410 non-text area, we treat the click as if it were prefixed by the
4411 symbol denoting that area - `mode-line', `vertical-line', or
4414 If the sequence starts with a mouse click, we read the key sequence
4415 with respect to the buffer clicked on, not the current buffer.
4417 If the user switches frames in the midst of a key sequence, we put
4418 off the switch-frame event until later; the next call to
4419 read_char will return it. */
4422 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
)
4423 Lisp_Object
*keybuf
;
4426 int dont_downcase_last
;
4428 int count
= specpdl_ptr
- specpdl
;
4430 /* How many keys there are in the current key sequence. */
4433 /* The length of the echo buffer when we started reading, and
4434 the length of this_command_keys when we started reading. */
4438 /* The number of keymaps we're scanning right now, and the number of
4439 keymaps we have allocated space for. */
4441 int nmaps_allocated
= 0;
4443 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
4444 the current keymaps. */
4447 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
4448 in the current keymaps, or nil where it is not a prefix. */
4449 Lisp_Object
*submaps
;
4451 /* The local map to start out with at start of key sequence. */
4452 Lisp_Object orig_local_map
;
4454 /* 1 if we have already considered switching to the local-map property
4455 of the place where a mouse click occurred. */
4456 int localized_local_map
= 0;
4458 /* The index in defs[] of the first keymap that has a binding for
4459 this key sequence. In other words, the lowest i such that
4460 defs[i] is non-nil. */
4463 /* If t < mock_input, then KEYBUF[t] should be read as the next
4466 We use this to recover after recognizing a function key. Once we
4467 realize that a suffix of the current key sequence is actually a
4468 function key's escape sequence, we replace the suffix with the
4469 function key's binding from Vfunction_key_map. Now keybuf
4470 contains a new and different key sequence, so the echo area,
4471 this_command_keys, and the submaps and defs arrays are wrong. In
4472 this situation, we set mock_input to t, set t to 0, and jump to
4473 restart_sequence; the loop will read keys from keybuf up until
4474 mock_input, thus rebuilding the state; and then it will resume
4475 reading characters from the keyboard. */
4478 /* If the sequence is unbound in submaps[], then
4479 keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
4480 and fkey_map is its binding.
4482 These might be > t, indicating that all function key scanning
4483 should hold off until t reaches them. We do this when we've just
4484 recognized a function key, to avoid searching for the function
4485 key's again in Vfunction_key_map. */
4486 int fkey_start
= 0, fkey_end
= 0;
4487 Lisp_Object fkey_map
;
4489 /* Likewise, for key_translation_map. */
4490 int keytran_start
= 0, keytran_end
= 0;
4491 Lisp_Object keytran_map
;
4493 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
4494 we put it off for later. While we're reading, we keep the event here. */
4495 Lisp_Object delayed_switch_frame
;
4497 /* See the comment below... */
4498 #if defined (GOBBLE_FIRST_EVENT)
4499 Lisp_Object first_event
;
4502 Lisp_Object original_uppercase
;
4503 int original_uppercase_position
= -1;
4505 /* Gets around Microsoft compiler limitations. */
4508 struct buffer
*starting_buffer
;
4510 /* Nonzero if we seem to have got the beginning of a binding
4511 in function_key_map. */
4512 int function_key_possible
= 0;
4513 int key_translation_possible
= 0;
4517 last_nonmenu_event
= Qnil
;
4519 delayed_switch_frame
= Qnil
;
4520 fkey_map
= Vfunction_key_map
;
4521 keytran_map
= Vkey_translation_map
;
4523 /* If there is no function-key-map, turn off function key scanning. */
4524 if (NILP (Fkeymapp (Vfunction_key_map
)))
4525 fkey_start
= fkey_end
= bufsize
+ 1;
4527 /* If there is no key-translation-map, turn off scanning. */
4528 if (NILP (Fkeymapp (Vkey_translation_map
)))
4529 keytran_start
= keytran_end
= bufsize
+ 1;
4534 echo_prompt (XSTRING (prompt
)->data
);
4535 else if (cursor_in_echo_area
&& echo_keystrokes
)
4536 /* This doesn't put in a dash if the echo buffer is empty, so
4537 you don't always see a dash hanging out in the minibuffer. */
4541 /* Record the initial state of the echo area and this_command_keys;
4542 we will need to restore them if we replay a key sequence. */
4544 echo_start
= echo_length ();
4545 keys_start
= this_command_key_count
;
4547 #if defined (GOBBLE_FIRST_EVENT)
4548 /* This doesn't quite work, because some of the things that read_char
4549 does cannot safely be bypassed. It seems too risky to try to make
4552 /* Read the first char of the sequence specially, before setting
4553 up any keymaps, in case a filter runs and switches buffers on us. */
4554 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
4556 #endif /* GOBBLE_FIRST_EVENT */
4558 orig_local_map
= get_local_map (PT
, current_buffer
);
4560 /* We jump here when the key sequence has been thoroughly changed, and
4561 we need to rescan it starting from the beginning. When we jump here,
4562 keybuf[0..mock_input] holds the sequence we should reread. */
4565 starting_buffer
= current_buffer
;
4566 function_key_possible
= 0;
4567 key_translation_possible
= 0;
4569 /* Build our list of keymaps.
4570 If we recognize a function key and replace its escape sequence in
4571 keybuf with its symbol, or if the sequence starts with a mouse
4572 click and we need to switch buffers, we jump back here to rebuild
4573 the initial keymaps from the current buffer. */
4577 if (!NILP (Voverriding_local_map
))
4580 if (nmaps
> nmaps_allocated
)
4582 submaps
= (Lisp_Object
*) alloca (nmaps
* sizeof (submaps
[0]));
4583 defs
= (Lisp_Object
*) alloca (nmaps
* sizeof (defs
[0]));
4584 nmaps_allocated
= nmaps
;
4586 submaps
[0] = Voverriding_local_map
;
4590 nmaps
= current_minor_maps (0, &maps
) + 2;
4591 if (nmaps
> nmaps_allocated
)
4593 submaps
= (Lisp_Object
*) alloca (nmaps
* sizeof (submaps
[0]));
4594 defs
= (Lisp_Object
*) alloca (nmaps
* sizeof (defs
[0]));
4595 nmaps_allocated
= nmaps
;
4597 bcopy (maps
, submaps
, (nmaps
- 2) * sizeof (submaps
[0]));
4598 #ifdef USE_TEXT_PROPERTIES
4599 submaps
[nmaps
-2] = orig_local_map
;
4601 submaps
[nmaps
-2] = current_buffer
->keymap
;
4604 submaps
[nmaps
-1] = current_global_map
;
4607 /* Find an accurate initial value for first_binding. */
4608 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
4609 if (! NILP (submaps
[first_binding
]))
4612 /* Start from the beginning in keybuf. */
4615 /* These are no-ops the first time through, but if we restart, they
4616 revert the echo area and this_command_keys to their original state. */
4617 this_command_key_count
= keys_start
;
4618 if (INTERACTIVE
&& t
< mock_input
)
4619 echo_truncate (echo_start
);
4621 /* If the best binding for the current key sequence is a keymap, or
4622 we may be looking at a function key's escape sequence, keep on
4624 while ((first_binding
< nmaps
&& ! NILP (submaps
[first_binding
]))
4625 || (first_binding
>= nmaps
4627 /* mock input is never part of a function key's sequence. */
4628 && mock_input
<= fkey_start
)
4629 || (first_binding
>= nmaps
4630 && keytran_start
< t
&& key_translation_possible
)
4631 /* Don't return in the middle of a possible function key sequence,
4632 if the only bindings we found were via case conversion.
4633 Thus, if ESC O a has a function-key-map translation
4634 and ESC o has a binding, don't return after ESC O,
4635 so that we can translate ESC O plus the next character. */
4639 int used_mouse_menu
= 0;
4641 /* Where the last real key started. If we need to throw away a
4642 key that has expanded into more than one element of keybuf
4643 (say, a mouse click on the mode line which is being treated
4644 as [mode-line (mouse-...)], then we backtrack to this point
4646 int last_real_key_start
;
4648 /* These variables are analogous to echo_start and keys_start;
4649 while those allow us to restart the entire key sequence,
4650 echo_local_start and keys_local_start allow us to throw away
4652 int echo_local_start
, keys_local_start
, local_first_binding
;
4655 error ("key sequence too long");
4658 echo_local_start
= echo_length ();
4659 keys_local_start
= this_command_key_count
;
4660 local_first_binding
= first_binding
;
4663 /* These are no-ops, unless we throw away a keystroke below and
4664 jumped back up to replay_key; in that case, these restore the
4665 variables to their original state, allowing us to replay the
4667 if (INTERACTIVE
&& t
< mock_input
)
4668 echo_truncate (echo_local_start
);
4669 this_command_key_count
= keys_local_start
;
4670 first_binding
= local_first_binding
;
4672 /* By default, assume each event is "real". */
4673 last_real_key_start
= t
;
4675 /* Does mock_input indicate that we are re-reading a key sequence? */
4679 add_command_key (key
);
4680 if (echo_keystrokes
)
4684 /* If not, we should actually read a character. */
4687 struct buffer
*buf
= current_buffer
;
4689 key
= read_char (NILP (prompt
), nmaps
, submaps
, last_nonmenu_event
,
4692 /* read_char returns t when it shows a menu and the user rejects it.
4697 /* read_char returns -1 at the end of a macro.
4698 Emacs 18 handles this by returning immediately with a
4699 zero, so that's what we'll do. */
4700 if (INTEGERP (key
) && XINT (key
) == -1)
4703 /* The Microsoft C compiler can't handle the goto that
4709 /* If the current buffer has been changed from under us, the
4710 keymap may have changed, so replay the sequence. */
4714 goto replay_sequence
;
4717 /* If we have a quit that was typed in another frame, and
4718 quit_throw_to_read_char switched buffers,
4719 replay to get the right keymap. */
4720 if (XINT (key
) == quit_char
&& current_buffer
!= starting_buffer
)
4725 goto replay_sequence
;
4731 /* Clicks in non-text areas get prefixed by the symbol
4732 in their CHAR-ADDRESS field. For example, a click on
4733 the mode line is prefixed by the symbol `mode-line'.
4735 Furthermore, key sequences beginning with mouse clicks
4736 are read using the keymaps of the buffer clicked on, not
4737 the current buffer. So we may have to switch the buffer
4740 When we turn one event into two events, we must make sure
4741 that neither of the two looks like the original--so that,
4742 if we replay the events, they won't be expanded again.
4743 If not for this, such reexpansion could happen either here
4744 or when user programs play with this-command-keys. */
4745 if (EVENT_HAS_PARAMETERS (key
))
4749 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
4750 if (EQ (kind
, Qmouse_click
))
4752 Lisp_Object window
, posn
;
4754 window
= POSN_WINDOW (EVENT_START (key
));
4755 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
4758 /* We're looking at the second event of a
4759 sequence which we expanded before. Set
4760 last_real_key_start appropriately. */
4762 last_real_key_start
= t
- 1;
4765 /* Key sequences beginning with mouse clicks are
4766 read using the keymaps in the buffer clicked on,
4767 not the current buffer. If we're at the
4768 beginning of a key sequence, switch buffers. */
4769 if (last_real_key_start
== 0
4771 && BUFFERP (XWINDOW (window
)->buffer
)
4772 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
4777 /* Arrange to go back to the original buffer once we're
4778 done reading the key sequence. Note that we can't
4779 use save_excursion_{save,restore} here, because they
4780 save point as well as the current buffer; we don't
4781 want to save point, because redisplay may change it,
4782 to accommodate a Fset_window_start or something. We
4783 don't want to do this at the top of the function,
4784 because we may get input from a subprocess which
4785 wants to change the selected window and stuff (say,
4787 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
4789 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
4790 orig_local_map
= get_local_map (PT
, current_buffer
);
4791 goto replay_sequence
;
4793 /* For a mouse click, get the local text-property keymap
4794 of the place clicked on, rather than point. */
4795 if (last_real_key_start
== 0 && CONSP (XCONS (key
)->cdr
)
4796 && ! localized_local_map
)
4798 Lisp_Object map_here
, start
, pos
;
4800 localized_local_map
= 1;
4801 start
= EVENT_START (key
);
4802 if (CONSP (start
) && CONSP (XCONS (start
)->cdr
))
4804 pos
= POSN_BUFFER_POSN (start
);
4807 map_here
= get_local_map (XINT (pos
), current_buffer
);
4808 if (!EQ (map_here
, orig_local_map
))
4810 orig_local_map
= map_here
;
4814 goto replay_sequence
;
4820 /* Expand mode-line and scroll-bar events into two events:
4821 use posn as a fake prefix key. */
4824 if (t
+ 1 >= bufsize
)
4825 error ("key sequence too long");
4830 /* Zap the position in key, so we know that we've
4831 expanded it, and don't try to do so again. */
4832 POSN_BUFFER_POSN (EVENT_START (key
))
4833 = Fcons (posn
, Qnil
);
4837 else if (EQ (kind
, Qswitch_frame
))
4839 /* If we're at the beginning of a key sequence, go
4840 ahead and return this event. If we're in the
4841 midst of a key sequence, delay it until the end. */
4844 delayed_switch_frame
= key
;
4848 else if (CONSP (XCONS (key
)->cdr
)
4849 && CONSP (EVENT_START (key
))
4850 && CONSP (XCONS (EVENT_START (key
))->cdr
))
4854 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
4855 /* Handle menu-bar events:
4856 insert the dummy prefix event `menu-bar'. */
4857 if (EQ (posn
, Qmenu_bar
))
4859 if (t
+ 1 >= bufsize
)
4860 error ("key sequence too long");
4861 /* Run the Lucid hook. */
4862 if (!NILP (Vrun_hooks
))
4863 call1 (Vrun_hooks
, Qactivate_menubar_hook
);
4864 /* If it has changed current-menubar from previous value,
4865 really recompute the menubar from the value. */
4866 if (! NILP (Vlucid_menu_bar_dirty_flag
))
4867 call0 (Qrecompute_lucid_menubar
);
4871 /* Zap the position in key, so we know that we've
4872 expanded it, and don't try to do so again. */
4873 POSN_BUFFER_POSN (EVENT_START (key
))
4874 = Fcons (posn
, Qnil
);
4877 goto replay_sequence
;
4879 else if (CONSP (posn
))
4881 /* We're looking at the second event of a
4882 sequence which we expanded before. Set
4883 last_real_key_start appropriately. */
4884 if (last_real_key_start
== t
&& t
> 0)
4885 last_real_key_start
= t
- 1;
4890 /* We have finally decided that KEY is something we might want
4892 first_binding
= (follow_key (key
,
4893 nmaps
- first_binding
,
4894 submaps
+ first_binding
,
4895 defs
+ first_binding
,
4896 submaps
+ first_binding
)
4899 /* If KEY wasn't bound, we'll try some fallbacks. */
4900 if (first_binding
>= nmaps
)
4904 head
= EVENT_HEAD (key
);
4905 if (EQ (head
, Vhelp_char
))
4907 read_key_sequence_cmd
= Vprefix_help_command
;
4909 last_nonmenu_event
= key
;
4910 /* The Microsoft C compiler can't handle the goto that
4918 Lisp_Object breakdown
;
4921 breakdown
= parse_modifiers (head
);
4922 modifiers
= XINT (XCONS (XCONS (breakdown
)->cdr
)->car
);
4923 /* Attempt to reduce an unbound mouse event to a simpler
4924 event that is bound:
4925 Drags reduce to clicks.
4926 Double-clicks reduce to clicks.
4927 Triple-clicks reduce to double-clicks, then to clicks.
4928 Down-clicks are eliminated.
4929 Double-downs reduce to downs, then are eliminated.
4930 Triple-downs reduce to double-downs, then to downs,
4931 then are eliminated. */
4932 if (modifiers
& (down_modifier
| drag_modifier
4933 | double_modifier
| triple_modifier
))
4935 while (modifiers
& (down_modifier
| drag_modifier
4936 | double_modifier
| triple_modifier
))
4938 Lisp_Object new_head
, new_click
;
4939 if (modifiers
& triple_modifier
)
4940 modifiers
^= (double_modifier
| triple_modifier
);
4941 else if (modifiers
& double_modifier
)
4942 modifiers
&= ~double_modifier
;
4943 else if (modifiers
& drag_modifier
)
4944 modifiers
&= ~drag_modifier
;
4947 /* Dispose of this `down' event by simply jumping
4948 back to replay_key, to get another event.
4950 Note that if this event came from mock input,
4951 then just jumping back to replay_key will just
4952 hand it to us again. So we have to wipe out any
4955 We could delete keybuf[t] and shift everything
4956 after that to the left by one spot, but we'd also
4957 have to fix up any variable that points into
4958 keybuf, and shifting isn't really necessary
4961 Adding prefixes for non-textual mouse clicks
4962 creates two characters of mock input, and both
4963 must be thrown away. If we're only looking at
4964 the prefix now, we can just jump back to
4965 replay_key. On the other hand, if we've already
4966 processed the prefix, and now the actual click
4967 itself is giving us trouble, then we've lost the
4968 state of the keymaps we want to backtrack to, and
4969 we need to replay the whole sequence to rebuild
4972 Beyond that, only function key expansion could
4973 create more than two keys, but that should never
4974 generate mouse events, so it's okay to zero
4975 mock_input in that case too.
4977 Isn't this just the most wonderful code ever? */
4978 if (t
== last_real_key_start
)
4985 mock_input
= last_real_key_start
;
4986 goto replay_sequence
;
4991 = apply_modifiers (modifiers
, XCONS (breakdown
)->car
);
4993 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
4995 /* Look for a binding for this new key. follow_key
4996 promises that it didn't munge submaps the
4997 last time we called it, since key was unbound. */
4999 = (follow_key (new_click
,
5000 nmaps
- local_first_binding
,
5001 submaps
+ local_first_binding
,
5002 defs
+ local_first_binding
,
5003 submaps
+ local_first_binding
)
5004 + local_first_binding
);
5006 /* If that click is bound, go for it. */
5007 if (first_binding
< nmaps
)
5012 /* Otherwise, we'll leave key set to the drag event. */
5019 /* Normally, last_nonmenu_event gets the previous key we read.
5020 But when a mouse popup menu is being used,
5021 we don't update last_nonmenu_event; it continues to hold the mouse
5022 event that preceded the first level of menu. */
5023 if (!used_mouse_menu
)
5024 last_nonmenu_event
= key
;
5026 /* If the sequence is unbound, see if we can hang a function key
5027 off the end of it. We only want to scan real keyboard input
5028 for function key sequences, so if mock_input says that we're
5029 re-reading old events, don't examine it. */
5030 if (first_binding
>= nmaps
5033 Lisp_Object fkey_next
;
5035 /* Continue scan from fkey_end until we find a bound suffix.
5036 If we fail, increment fkey_start
5037 and start fkey_end from there. */
5038 while (fkey_end
< t
)
5042 key
= keybuf
[fkey_end
++];
5043 /* Look up meta-characters by prefixing them
5044 with meta_prefix_char. I hate this. */
5045 if (INTEGERP (key
) && XINT (key
) & meta_modifier
)
5050 (access_keymap (fkey_map
, meta_prefix_char
, 1, 0)),
5052 XSETFASTINT (key
, XFASTINT (key
) & ~meta_modifier
);
5055 fkey_next
= fkey_map
;
5058 = get_keyelt (access_keymap (fkey_next
, key
, 1, 0));
5060 #if 0 /* I didn't turn this on, because it might cause trouble
5061 for the mapping of return into C-m and tab into C-i. */
5062 /* Optionally don't map function keys into other things.
5063 This enables the user to redefine kp- keys easily. */
5064 if (SYMBOLP (key
) && !NILP (Vinhibit_function_key_mapping
))
5068 /* If the function key map gives a function, not an
5069 array, then call the function with no args and use
5070 its value instead. */
5071 if (SYMBOLP (fkey_next
) && ! NILP (Ffboundp (fkey_next
))
5074 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5078 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
5079 fkey_next
= call1 (fkey_next
, prompt
);
5081 /* If the function returned something invalid,
5082 barf--don't ignore it.
5083 (To ignore it safely, we would need to gcpro a bunch of
5084 other variables.) */
5085 if (! (VECTORP (fkey_next
) || STRINGP (fkey_next
)))
5086 error ("Function in function-key-map returns invalid key sequence");
5089 function_key_possible
= ! NILP (fkey_next
);
5091 /* If keybuf[fkey_start..fkey_end] is bound in the
5092 function key map and it's a suffix of the current
5093 sequence (i.e. fkey_end == t), replace it with
5094 the binding and restart with fkey_start at the end. */
5095 if ((VECTORP (fkey_next
) || STRINGP (fkey_next
))
5098 int len
= XFASTINT (Flength (fkey_next
));
5100 t
= fkey_start
+ len
;
5102 error ("key sequence too long");
5104 if (VECTORP (fkey_next
))
5105 bcopy (XVECTOR (fkey_next
)->contents
,
5106 keybuf
+ fkey_start
,
5107 (t
- fkey_start
) * sizeof (keybuf
[0]));
5108 else if (STRINGP (fkey_next
))
5112 for (i
= 0; i
< len
; i
++)
5113 XSETFASTINT (keybuf
[fkey_start
+ i
],
5114 XSTRING (fkey_next
)->data
[i
]);
5118 fkey_start
= fkey_end
= t
;
5119 fkey_map
= Vfunction_key_map
;
5121 /* Do pass the results through key-translation-map. */
5122 keytran_start
= keytran_end
= 0;
5123 keytran_map
= Vkey_translation_map
;
5125 goto replay_sequence
;
5128 fkey_map
= get_keymap_1 (fkey_next
, 0, 1);
5130 /* If we no longer have a bound suffix, try a new positions for
5132 if (NILP (fkey_map
))
5134 fkey_end
= ++fkey_start
;
5135 fkey_map
= Vfunction_key_map
;
5136 function_key_possible
= 0;
5141 /* Look for this sequence in key-translation-map. */
5143 Lisp_Object keytran_next
;
5145 /* Scan from keytran_end until we find a bound suffix. */
5146 while (keytran_end
< t
)
5150 key
= keybuf
[keytran_end
++];
5151 /* Look up meta-characters by prefixing them
5152 with meta_prefix_char. I hate this. */
5153 if (INTEGERP (key
) && XINT (key
) & meta_modifier
)
5158 (access_keymap (keytran_map
, meta_prefix_char
, 1, 0)),
5160 XSETFASTINT (key
, XFASTINT (key
) & ~meta_modifier
);
5163 keytran_next
= keytran_map
;
5166 = get_keyelt (access_keymap (keytran_next
, key
, 1, 0));
5168 /* If the key translation map gives a function, not an
5169 array, then call the function with no args and use
5170 its value instead. */
5171 if (SYMBOLP (keytran_next
) && ! NILP (Ffboundp (keytran_next
))
5172 && keytran_end
== t
)
5174 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5178 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
5179 keytran_next
= call1 (keytran_next
, prompt
);
5181 /* If the function returned something invalid,
5182 barf--don't ignore it.
5183 (To ignore it safely, we would need to gcpro a bunch of
5184 other variables.) */
5185 if (! (VECTORP (keytran_next
) || STRINGP (keytran_next
)))
5186 error ("Function in key-translation-map returns invalid key sequence");
5189 key_translation_possible
= ! NILP (keytran_next
);
5191 /* If keybuf[keytran_start..keytran_end] is bound in the
5192 key translation map and it's a suffix of the current
5193 sequence (i.e. keytran_end == t), replace it with
5194 the binding and restart with keytran_start at the end. */
5195 if ((VECTORP (keytran_next
) || STRINGP (keytran_next
))
5196 && keytran_end
== t
)
5198 int len
= XFASTINT (Flength (keytran_next
));
5200 t
= keytran_start
+ len
;
5202 error ("key sequence too long");
5204 if (VECTORP (keytran_next
))
5205 bcopy (XVECTOR (keytran_next
)->contents
,
5206 keybuf
+ keytran_start
,
5207 (t
- keytran_start
) * sizeof (keybuf
[0]));
5208 else if (STRINGP (keytran_next
))
5212 for (i
= 0; i
< len
; i
++)
5213 XSETFASTINT (keybuf
[keytran_start
+ i
],
5214 XSTRING (keytran_next
)->data
[i
]);
5218 keytran_start
= keytran_end
= t
;
5219 keytran_map
= Vkey_translation_map
;
5221 /* Don't pass the results of key-translation-map
5222 through function-key-map. */
5223 fkey_start
= fkey_end
= t
;
5224 fkey_map
= Vkey_translation_map
;
5226 goto replay_sequence
;
5229 keytran_map
= get_keymap_1 (keytran_next
, 0, 1);
5231 /* If we no longer have a bound suffix, try a new positions for
5233 if (NILP (keytran_map
))
5235 keytran_end
= ++keytran_start
;
5236 keytran_map
= Vkey_translation_map
;
5237 key_translation_possible
= 0;
5242 /* If KEY is not defined in any of the keymaps,
5243 and cannot be part of a function key or translation,
5244 and is an upper case letter
5245 use the corresponding lower-case letter instead. */
5246 if (first_binding
== nmaps
&& ! function_key_possible
5247 && ! key_translation_possible
5249 && ((((XINT (key
) & 0x3ffff)
5250 < XSTRING (current_buffer
->downcase_table
)->size
)
5251 && UPPERCASEP (XINT (key
) & 0x3ffff))
5252 || (XINT (key
) & shift_modifier
)))
5254 original_uppercase
= key
;
5255 original_uppercase_position
= t
- 1;
5257 if (XINT (key
) & shift_modifier
)
5258 XSETINT (key
, XINT (key
) & ~shift_modifier
);
5260 XSETINT (key
, (DOWNCASE (XINT (key
) & 0x3ffff)
5261 | (XINT (key
) & ~0x3ffff)));
5263 keybuf
[t
- 1] = key
;
5265 goto replay_sequence
;
5267 /* If KEY is not defined in any of the keymaps,
5268 and cannot be part of a function key or translation,
5269 and is a shifted function key,
5270 use the corresponding unshifted function key instead. */
5271 if (first_binding
== nmaps
&& ! function_key_possible
5272 && ! key_translation_possible
5275 Lisp_Object breakdown
;
5278 original_uppercase
= key
;
5279 original_uppercase_position
= t
- 1;
5281 breakdown
= parse_modifiers (key
);
5282 modifiers
= XINT (XCONS (XCONS (breakdown
)->cdr
)->car
);
5283 if (modifiers
& shift_modifier
)
5285 modifiers
&= ~shift_modifier
;
5286 key
= apply_modifiers (make_number (modifiers
),
5287 XCONS (breakdown
)->car
);
5289 keybuf
[t
- 1] = key
;
5291 goto replay_sequence
;
5297 read_key_sequence_cmd
= (first_binding
< nmaps
5298 ? defs
[first_binding
]
5301 unread_switch_frame
= delayed_switch_frame
;
5302 unbind_to (count
, Qnil
);
5304 if (dont_downcase_last
&& t
- 1 == original_uppercase_position
)
5305 keybuf
[t
- 1] = original_uppercase
;
5307 /* Occasionally we fabricate events, perhaps by expanding something
5308 according to function-key-map, or by adding a prefix symbol to a
5309 mouse click in the scroll bar or modeline. In this cases, return
5310 the entire generated key sequence, even if we hit an unbound
5311 prefix or a definition before the end. This means that you will
5312 be able to push back the event properly, and also means that
5313 read-key-sequence will always return a logical unit.
5316 for (; t
< mock_input
; t
++)
5318 if (echo_keystrokes
)
5319 echo_char (keybuf
[t
]);
5320 add_command_key (keybuf
[t
]);
5326 #if 0 /* This doc string is too long for some compilers.
5327 This commented-out definition serves for DOC. */
5328 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 2, 0,
5329 "Read a sequence of keystrokes and return as a string or vector.\n\
5330 The sequence is sufficient to specify a non-prefix command in the\n\
5331 current local and global maps.\n\
5333 First arg PROMPT is a prompt string. If nil, do not prompt specially.\n\
5334 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
5335 as a continuation of the previous key.\n\
5337 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not\n\
5338 convert the last event to lower case. (Normally any upper case event\n\
5339 is converted to lower case if the original event is undefined and the lower\n\
5340 case equivalent is defined.) A non-nil value is appropriate for reading\n\
5341 a key sequence to be defined.\n\
5343 A C-g typed while in this function is treated like any other character,\n\
5344 and `quit-flag' is not set.\n\
5346 If the key sequence starts with a mouse click, then the sequence is read\n\
5347 using the keymaps of the buffer of the window clicked in, not the buffer\n\
5348 of the selected window as normal.\n\
5350 `read-key-sequence' drops unbound button-down events, since you normally\n\
5351 only care about the click or drag events which follow them. If a drag\n\
5352 or multi-click event is unbound, but the corresponding click event would\n\
5353 be bound, `read-key-sequence' turns the event into a click event at the\n\
5354 drag's starting position. This means that you don't have to distinguish\n\
5355 between click and drag, double, or triple events unless you want to.\n\
5357 `read-key-sequence' prefixes mouse events on mode lines, the vertical\n\
5358 lines separating windows, and scroll bars with imaginary keys\n\
5359 `mode-line', `vertical-line', and `vertical-scroll-bar'.\n\
5361 If the user switches frames in the middle of a key sequence, the\n\
5362 frame-switch event is put off until after the current key sequence.\n\
5364 `read-key-sequence' checks `function-key-map' for function key\n\
5365 sequences, where they wouldn't conflict with ordinary bindings. See\n\
5366 `function-key-map' for more details.")
5367 (prompt
, continue_echo
)
5370 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 3, 0,
5372 (prompt
, continue_echo
, dont_downcase_last
)
5373 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
5375 Lisp_Object keybuf
[30];
5377 struct gcpro gcpro1
, gcpro2
;
5380 CHECK_STRING (prompt
, 0);
5383 bzero (keybuf
, sizeof keybuf
);
5385 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
5387 if (NILP (continue_echo
))
5388 this_command_key_count
= 0;
5390 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
5391 prompt
, ! NILP (dont_downcase_last
));
5399 return make_event_array (i
, keybuf
);
5402 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 2, 0,
5403 "Execute CMD as an editor command.\n\
5404 CMD must be a symbol that satisfies the `commandp' predicate.\n\
5405 Optional second arg RECORD-FLAG non-nil\n\
5406 means unconditionally put this command in `command-history'.\n\
5407 Otherwise, that is done only if an arg is read using the minibuffer.")
5409 Lisp_Object cmd
, record
;
5411 register Lisp_Object final
;
5412 register Lisp_Object tem
;
5413 Lisp_Object prefixarg
;
5414 struct backtrace backtrace
;
5415 extern int debug_on_next_call
;
5417 prefixarg
= Vprefix_arg
, Vprefix_arg
= Qnil
;
5418 Vcurrent_prefix_arg
= prefixarg
;
5419 debug_on_next_call
= 0;
5423 tem
= Fget (cmd
, Qdisabled
);
5424 if (!NILP (tem
) && !NILP (Vrun_hooks
))
5425 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
5430 final
= Findirect_function (cmd
);
5432 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
5433 do_autoload (final
, cmd
);
5438 if (STRINGP (final
) || VECTORP (final
))
5440 /* If requested, place the macro in the command history. For
5441 other sorts of commands, call-interactively takes care of
5445 = Fcons (Fcons (Qexecute_kbd_macro
,
5446 Fcons (final
, Fcons (prefixarg
, Qnil
))),
5449 return Fexecute_kbd_macro (final
, prefixarg
);
5451 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
5453 backtrace
.next
= backtrace_list
;
5454 backtrace_list
= &backtrace
;
5455 backtrace
.function
= &Qcall_interactively
;
5456 backtrace
.args
= &cmd
;
5457 backtrace
.nargs
= 1;
5458 backtrace
.evalargs
= 0;
5460 tem
= Fcall_interactively (cmd
, record
);
5462 backtrace_list
= backtrace
.next
;
5468 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
5470 "Read function name, then read its arguments and call it.")
5472 Lisp_Object prefixarg
;
5474 Lisp_Object function
;
5476 Lisp_Object saved_keys
;
5477 struct gcpro gcpro1
;
5479 saved_keys
= Fvector (this_command_key_count
,
5480 XVECTOR (this_command_keys
)->contents
);
5482 GCPRO1 (saved_keys
);
5484 if (EQ (prefixarg
, Qminus
))
5486 else if (CONSP (prefixarg
) && XINT (XCONS (prefixarg
)->car
) == 4)
5487 strcpy (buf
, "C-u ");
5488 else if (CONSP (prefixarg
) && INTEGERP (XCONS (prefixarg
)->car
))
5489 sprintf (buf
, "%d ", XINT (XCONS (prefixarg
)->car
));
5490 else if (INTEGERP (prefixarg
))
5491 sprintf (buf
, "%d ", XINT (prefixarg
));
5493 /* This isn't strictly correct if execute-extended-command
5494 is bound to anything else. Perhaps it should use
5495 this_command_keys? */
5496 strcat (buf
, "M-x ");
5498 /* Prompt with buf, and then read a string, completing from and
5499 restricting to the set of all defined commands. Don't provide
5500 any initial input. Save the command read on the extended-command
5502 function
= Fcompleting_read (build_string (buf
),
5503 Vobarray
, Qcommandp
,
5504 Qt
, Qnil
, Qextended_command_history
);
5506 /* Set this_command_keys to the concatenation of saved_keys and
5507 function, followed by a RET. */
5509 struct Lisp_String
*str
;
5514 this_command_key_count
= 0;
5516 keys
= XVECTOR (saved_keys
)->contents
;
5517 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
5518 add_command_key (keys
[i
]);
5520 str
= XSTRING (function
);
5521 for (i
= 0; i
< str
->size
; i
++)
5523 XSETFASTINT (tem
, str
->data
[i
]);
5524 add_command_key (tem
);
5527 XSETFASTINT (tem
, '\015');
5528 add_command_key (tem
);
5533 function
= Fintern (function
, Qnil
);
5534 Vprefix_arg
= prefixarg
;
5535 this_command
= function
;
5537 return Fcommand_execute (function
, Qt
);
5541 detect_input_pending ()
5544 get_input_pending (&input_pending
);
5546 return input_pending
;
5549 /* This is called in some cases before a possible quit.
5550 It cases the next call to detect_input_pending to recompute input_pending.
5551 So calling this function unnecessarily can't do any harm. */
5552 clear_input_pending ()
5557 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
5558 "T if command input is currently available with no waiting.\n\
5559 Actually, the value is nil only if we can be sure that no input is available.")
5562 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
5565 return detect_input_pending () ? Qt
: Qnil
;
5568 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
5569 "Return vector of last 100 events, not counting those from keyboard macros.")
5572 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
5575 if (total_keys
< NUM_RECENT_KEYS
)
5576 return Fvector (total_keys
, keys
);
5579 val
= Fvector (NUM_RECENT_KEYS
, keys
);
5580 bcopy (keys
+ recent_keys_index
,
5581 XVECTOR (val
)->contents
,
5582 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
5584 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
5585 recent_keys_index
* sizeof (Lisp_Object
));
5590 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
5591 "Return the key sequence that invoked this command.\n\
5592 The value is a string or a vector.")
5595 return make_event_array (this_command_key_count
,
5596 XVECTOR (this_command_keys
)->contents
);
5599 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
5600 "Return the current depth in recursive edits.")
5604 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
5608 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
5609 "FOpen dribble file: ",
5610 "Start writing all keyboard characters to a dribble file called FILE.\n\
5611 If FILE is nil, close any open dribble file.")
5625 file
= Fexpand_file_name (file
, Qnil
);
5626 dribble
= fopen (XSTRING (file
)->data
, "w");
5631 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
5632 "Discard the contents of the terminal input buffer.\n\
5633 Also cancel any kbd macro being defined.")
5636 PERDISPLAY
*perd
= &the_only_perdisplay
;
5637 defining_kbd_macro
= 0;
5638 update_mode_lines
++;
5640 Vunread_command_events
= Qnil
;
5641 unread_command_char
= -1;
5643 discard_tty_input ();
5645 /* Without the cast, GCC complains that this assignment loses the
5646 volatile qualifier of kbd_store_ptr. Is there anything wrong
5648 perd
->kbd_fetch_ptr
= (struct input_event
*) perd
->kbd_store_ptr
;
5649 Ffillarray (perd
->kbd_buffer_frame_or_window
, Qnil
);
5655 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
5656 "Stop Emacs and return to superior process. You can resume later.\n\
5657 If `cannot-suspend' is non-nil, or if the system doesn't support job\n\
5658 control, run a subshell instead.\n\n\
5659 If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
5660 to be read as terminal input by Emacs's parent, after suspension.\n\
5662 Before suspending, run the normal hook `suspend-hook'.\n\
5663 After resumption run the normal hook `suspend-resume-hook'.\n\
5665 Some operating systems cannot stop the Emacs process and resume it later.\n\
5666 On such systems, Emacs starts a subshell instead of suspending.")
5668 Lisp_Object stuffstring
;
5671 int count
= specpdl_ptr
- specpdl
;
5672 int old_height
, old_width
;
5674 struct gcpro gcpro1
, gcpro2
;
5675 extern init_sys_modes ();
5677 if (!NILP (stuffstring
))
5678 CHECK_STRING (stuffstring
, 0);
5680 /* Run the functions in suspend-hook. */
5681 if (!NILP (Vrun_hooks
))
5682 call1 (Vrun_hooks
, intern ("suspend-hook"));
5684 GCPRO1 (stuffstring
);
5685 get_frame_size (&old_width
, &old_height
);
5687 /* sys_suspend can get an error if it tries to fork a subshell
5688 and the system resources aren't available for that. */
5689 record_unwind_protect (init_sys_modes
, 0);
5690 stuff_buffered_input (stuffstring
);
5695 unbind_to (count
, Qnil
);
5697 /* Check if terminal/window size has changed.
5698 Note that this is not useful when we are running directly
5699 with a window system; but suspend should be disabled in that case. */
5700 get_frame_size (&width
, &height
);
5701 if (width
!= old_width
|| height
!= old_height
)
5702 change_frame_size (selected_frame
, height
, width
, 0, 0);
5704 /* Run suspend-resume-hook. */
5705 if (!NILP (Vrun_hooks
))
5706 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
5712 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
5713 Then in any case stuff anything Emacs has read ahead and not used. */
5715 stuff_buffered_input (stuffstring
)
5716 Lisp_Object stuffstring
;
5718 /* stuff_char works only in BSD, versions 4.2 and up. */
5721 register unsigned char *p
;
5722 PERDISPLAY
*perd
= &the_only_perdisplay
; /* We really want the primary display's perd */
5724 if (STRINGP (stuffstring
))
5728 p
= XSTRING (stuffstring
)->data
;
5729 count
= XSTRING (stuffstring
)->size
;
5734 /* Anything we have read ahead, put back for the shell to read. */
5735 while (perd
->kbd_fetch_ptr
!= perd
->kbd_store_ptr
)
5737 if (perd
->kbd_fetch_ptr
== perd
->kbd_buffer
+ KBD_BUFFER_SIZE
)
5738 perd
->kbd_fetch_ptr
= perd
->kbd_buffer
;
5739 if (perd
->kbd_fetch_ptr
->kind
== ascii_keystroke
)
5740 stuff_char (perd
->kbd_fetch_ptr
->code
);
5741 perd
->kbd_fetch_ptr
->kind
= no_event
;
5742 (XVECTOR (perd
->kbd_buffer_frame_or_window
)->contents
[perd
->kbd_fetch_ptr
5745 perd
->kbd_fetch_ptr
++;
5749 #endif /* BSD and not BSD4_1 */
5752 set_waiting_for_input (time_to_clear
)
5753 EMACS_TIME
*time_to_clear
;
5755 input_available_clear_time
= time_to_clear
;
5757 /* Tell interrupt_signal to throw back to read_char, */
5758 waiting_for_input
= 1;
5760 /* If interrupt_signal was called before and buffered a C-g,
5761 make it run again now, to avoid timing error. */
5762 if (!NILP (Vquit_flag
))
5763 quit_throw_to_read_char ();
5766 clear_waiting_for_input ()
5768 /* Tell interrupt_signal not to throw back to read_char, */
5769 waiting_for_input
= 0;
5770 input_available_clear_time
= 0;
5773 /* This routine is called at interrupt level in response to C-G.
5774 If interrupt_input, this is the handler for SIGINT.
5775 Otherwise, it is called from kbd_buffer_store_event,
5776 in handling SIGIO or SIGTINT.
5778 If `waiting_for_input' is non zero, then unless `echoing' is nonzero,
5779 immediately throw back to read_char.
5781 Otherwise it sets the Lisp variable quit-flag not-nil.
5782 This causes eval to throw, when it gets a chance.
5783 If quit-flag is already non-nil, it stops the job right away. */
5789 /* Must preserve main program's value of errno. */
5790 int old_errno
= errno
;
5793 if (!read_socket_hook
&& NILP (Vwindow_system
))
5795 /* USG systems forget handlers when they are used;
5796 must reestablish each time */
5797 signal (SIGINT
, interrupt_signal
);
5798 signal (SIGQUIT
, interrupt_signal
);
5804 if (!NILP (Vquit_flag
) && FRAME_TERMCAP_P (selected_frame
))
5809 #ifdef SIGTSTP /* Support possible in later USG versions */
5811 * On systems which can suspend the current process and return to the original
5812 * shell, this command causes the user to end up back at the shell.
5813 * The "Auto-save" and "Abort" questions are not asked until
5814 * the user elects to return to emacs, at which point he can save the current
5815 * job and either dump core or continue.
5820 if (sys_suspend () == -1)
5822 printf ("Not running as a subprocess;\n");
5823 printf ("you can continue or abort.\n");
5826 /* Perhaps should really fork an inferior shell?
5827 But that would not provide any way to get back
5828 to the original shell, ever. */
5829 printf ("No support for stopping a process on this operating system;\n");
5830 printf ("you can continue or abort.\n");
5831 #endif /* not VMS */
5832 #endif /* not SIGTSTP */
5834 /* We must remain inside the screen area when the internal terminal
5835 is used. Note that [Enter] is not echoed by dos. */
5838 printf ("Auto-save? (y or n) ");
5840 if (((c
= getchar ()) & ~040) == 'Y')
5842 Fdo_auto_save (Qt
, Qnil
);
5844 printf ("\r\nAuto-save done");
5845 #else /* not MSDOS */
5846 printf ("Auto-save done\n");
5847 #endif /* not MSDOS */
5849 while (c
!= '\n') c
= getchar ();
5851 printf ("\r\nAbort? (y or n) ");
5852 #else /* not MSDOS */
5854 printf ("Abort (and enter debugger)? (y or n) ");
5856 printf ("Abort (and dump core)? (y or n) ");
5857 #endif /* not VMS */
5858 #endif /* not MSDOS */
5860 if (((c
= getchar ()) & ~040) == 'Y')
5862 while (c
!= '\n') c
= getchar ();
5864 printf ("\r\nContinuing...\r\n");
5865 #else /* not MSDOS */
5866 printf ("Continuing...\n");
5867 #endif /* not MSDOS */
5873 /* If executing a function that wants to be interrupted out of
5874 and the user has not deferred quitting by binding `inhibit-quit'
5875 then quit right away. */
5876 if (immediate_quit
&& NILP (Vinhibit_quit
))
5880 Fsignal (Qquit
, Qnil
);
5883 /* Else request quit when it's safe */
5887 if (waiting_for_input
&& !echoing
)
5888 quit_throw_to_read_char ();
5893 /* Handle a C-g by making read_char return C-g. */
5895 quit_throw_to_read_char ()
5897 quit_error_check ();
5899 /* Prevent another signal from doing this before we finish. */
5900 clear_waiting_for_input ();
5903 Vunread_command_events
= Qnil
;
5904 unread_command_char
= -1;
5906 #ifdef POLL_FOR_INPUT
5907 /* May be > 1 if in recursive minibuffer. */
5908 if (poll_suppress_count
== 0)
5912 if (FRAMEP (internal_last_event_frame
)
5913 && XFRAME (internal_last_event_frame
) != selected_frame
)
5914 Fhandle_switch_frame (make_lispy_switch_frame (internal_last_event_frame
));
5917 _longjmp (getcjmp
, 1);
5920 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
5921 "Set mode of reading keyboard input.\n\
5922 First arg INTERRUPT non-nil means use input interrupts;\n\
5923 nil means use CBREAK mode.\n\
5924 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal\n\
5925 (no effect except in CBREAK mode).\n\
5926 Third arg META t means accept 8-bit input (for a Meta key).\n\
5927 META nil means ignore the top bit, on the assumption it is parity.\n\
5928 Otherwise, accept 8-bit input and don't use the top bit for Meta.\n\
5929 Optional fourth arg QUIT if non-nil specifies character to use for quitting.\n\
5930 See also `current-input-mode'.")
5931 (interrupt
, flow
, meta
, quit
)
5932 Lisp_Object interrupt
, flow
, meta
, quit
;
5935 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
5936 error ("set-input-mode: QUIT must be an ASCII character");
5938 #ifdef POLL_FOR_INPUT
5944 /* Note SIGIO has been undef'd if FIONREAD is missing. */
5945 #ifdef NO_SOCK_SIGIO
5946 if (read_socket_hook
)
5947 interrupt_input
= 0; /* No interrupts if reading from a socket. */
5949 #endif /* NO_SOCK_SIGIO */
5950 interrupt_input
= !NILP (interrupt
);
5951 #else /* not SIGIO */
5952 interrupt_input
= 0;
5953 #endif /* not SIGIO */
5954 /* Our VMS input only works by interrupts, as of now. */
5956 interrupt_input
= 1;
5958 flow_control
= !NILP (flow
);
5961 else if (EQ (meta
, Qt
))
5966 /* Don't let this value be out of range. */
5967 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
5971 #ifdef POLL_FOR_INPUT
5972 poll_suppress_count
= 1;
5978 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
5979 "Return information about the way Emacs currently reads keyboard input.\n\
5980 The value is a list of the form (INTERRUPT FLOW META QUIT), where\n\
5981 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if\n\
5982 nil, Emacs is using CBREAK mode.\n\
5983 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the\n\
5984 terminal; this does not apply if Emacs uses interrupt-driven input.\n\
5985 META is t if accepting 8-bit input with 8th bit as Meta flag.\n\
5986 META nil means ignoring the top bit, on the assumption it is parity.\n\
5987 META is neither t nor nil if accepting 8-bit input and using\n\
5988 all 8 bits as the character code.\n\
5989 QUIT is the character Emacs currently uses to quit.\n\
5990 The elements of this list correspond to the arguments of\n\
5996 val
[0] = interrupt_input
? Qt
: Qnil
;
5997 val
[1] = flow_control
? Qt
: Qnil
;
5998 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
5999 XSETFASTINT (val
[3], quit_char
);
6001 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
6007 /* This is correct before outermost invocation of the editor loop */
6008 command_loop_level
= -1;
6010 quit_char
= Ctl ('g');
6011 Vunread_command_events
= Qnil
;
6012 unread_command_char
= -1;
6014 recent_keys_index
= 0;
6015 the_only_perdisplay
.kbd_buffer
6016 = (struct input_event
*)xmalloc (KBD_BUFFER_SIZE
6017 * sizeof (struct input_event
));
6018 the_only_perdisplay
.kbd_fetch_ptr
= the_only_perdisplay
.kbd_buffer
;
6019 the_only_perdisplay
.kbd_store_ptr
= the_only_perdisplay
.kbd_buffer
;
6021 do_mouse_tracking
= Qnil
;
6026 /* This means that command_loop_1 won't try to select anything the first
6028 internal_last_event_frame
= Qnil
;
6029 Vlast_event_frame
= internal_last_event_frame
;
6032 /* If we're running a dumped Emacs, we need to clear out
6033 kbd_buffer_frame_or_window, in case some events got into it
6036 If we're running an undumped Emacs, it hasn't been initialized by
6037 syms_of_keyboard yet. */
6041 perd
= &the_only_perdisplay
;
6042 /* FOR_ALL_PERDISPLAYS (perd) */
6044 Ffillarray (perd
->kbd_buffer_frame_or_window
, Qnil
);
6048 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
6050 signal (SIGINT
, interrupt_signal
);
6051 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
6052 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
6053 SIGQUIT and we can't tell which one it will give us. */
6054 signal (SIGQUIT
, interrupt_signal
);
6055 #endif /* HAVE_TERMIO */
6057 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6059 if (!noninteractive
)
6060 signal (SIGIO
, input_available_signal
);
6063 /* Use interrupt input by default, if it works and noninterrupt input
6064 has deficiencies. */
6066 #ifdef INTERRUPT_INPUT
6067 interrupt_input
= 1;
6069 interrupt_input
= 0;
6072 /* Our VMS input only works by interrupts, as of now. */
6074 interrupt_input
= 1;
6080 if (keyboard_init_hook
)
6081 (*keyboard_init_hook
) ();
6083 #ifdef POLL_FOR_INPUT
6084 poll_suppress_count
= 1;
6089 /* This type's only use is in syms_of_keyboard, to initialize the
6090 event header symbols and put properties on them. */
6097 struct event_head head_table
[] = {
6098 &Qmouse_movement
, "mouse-movement", &Qmouse_movement
,
6099 &Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
,
6100 &Qswitch_frame
, "switch-frame", &Qswitch_frame
,
6101 &Qdelete_frame
, "delete-frame", &Qdelete_frame
,
6102 &Qiconify_frame
, "iconify-frame", &Qiconify_frame
,
6103 &Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
,
6108 Qdisabled_command_hook
= intern ("disabled-command-hook");
6109 staticpro (&Qdisabled_command_hook
);
6111 Qself_insert_command
= intern ("self-insert-command");
6112 staticpro (&Qself_insert_command
);
6114 Qforward_char
= intern ("forward-char");
6115 staticpro (&Qforward_char
);
6117 Qbackward_char
= intern ("backward-char");
6118 staticpro (&Qbackward_char
);
6120 Qdisabled
= intern ("disabled");
6121 staticpro (&Qdisabled
);
6123 Qundefined
= intern ("undefined");
6124 staticpro (&Qundefined
);
6126 Qpre_command_hook
= intern ("pre-command-hook");
6127 staticpro (&Qpre_command_hook
);
6129 Qpost_command_hook
= intern ("post-command-hook");
6130 staticpro (&Qpost_command_hook
);
6132 Qdeferred_action_function
= intern ("deferred-action-function");
6133 staticpro (&Qdeferred_action_function
);
6135 Qcommand_hook_internal
= intern ("command-hook-internal");
6136 staticpro (&Qcommand_hook_internal
);
6138 Qfunction_key
= intern ("function-key");
6139 staticpro (&Qfunction_key
);
6140 Qmouse_click
= intern ("mouse-click");
6141 staticpro (&Qmouse_click
);
6143 Qmenu_enable
= intern ("menu-enable");
6144 staticpro (&Qmenu_enable
);
6146 Qmode_line
= intern ("mode-line");
6147 staticpro (&Qmode_line
);
6148 Qvertical_line
= intern ("vertical-line");
6149 staticpro (&Qvertical_line
);
6150 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
6151 staticpro (&Qvertical_scroll_bar
);
6152 Qmenu_bar
= intern ("menu-bar");
6153 staticpro (&Qmenu_bar
);
6155 Qabove_handle
= intern ("above-handle");
6156 staticpro (&Qabove_handle
);
6157 Qhandle
= intern ("handle");
6158 staticpro (&Qhandle
);
6159 Qbelow_handle
= intern ("below-handle");
6160 staticpro (&Qbelow_handle
);
6162 Qevent_kind
= intern ("event-kind");
6163 staticpro (&Qevent_kind
);
6164 Qevent_symbol_elements
= intern ("event-symbol-elements");
6165 staticpro (&Qevent_symbol_elements
);
6166 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
6167 staticpro (&Qevent_symbol_element_mask
);
6168 Qmodifier_cache
= intern ("modifier-cache");
6169 staticpro (&Qmodifier_cache
);
6171 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
6172 staticpro (&Qrecompute_lucid_menubar
);
6173 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
6174 staticpro (&Qactivate_menubar_hook
);
6176 Qpolling_period
= intern ("polling-period");
6177 staticpro (&Qpolling_period
);
6180 struct event_head
*p
;
6182 for (p
= head_table
;
6183 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
6186 *p
->var
= intern (p
->name
);
6188 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
6189 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
6193 button_down_location
= Fmake_vector (make_number (NUM_MOUSE_BUTTONS
), Qnil
);
6194 staticpro (&button_down_location
);
6198 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
6200 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
6201 for (i
= 0; i
< len
; i
++)
6202 if (modifier_names
[i
])
6203 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
6204 staticpro (&modifier_symbols
);
6207 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
6208 staticpro (&recent_keys
);
6210 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
6211 staticpro (&this_command_keys
);
6213 Qextended_command_history
= intern ("extended-command-history");
6214 Fset (Qextended_command_history
, Qnil
);
6215 staticpro (&Qextended_command_history
);
6217 the_only_perdisplay
.kbd_buffer_frame_or_window
6218 = Fmake_vector (make_number (KBD_BUFFER_SIZE
), Qnil
);
6219 staticpro (&the_only_perdisplay
.kbd_buffer_frame_or_window
);
6221 accent_key_syms
= Qnil
;
6222 staticpro (&accent_key_syms
);
6224 func_key_syms
= Qnil
;
6225 staticpro (&func_key_syms
);
6227 system_key_syms
= Qnil
;
6228 staticpro (&system_key_syms
);
6231 staticpro (&mouse_syms
);
6233 unread_switch_frame
= Qnil
;
6234 staticpro (&unread_switch_frame
);
6236 defsubr (&Sread_key_sequence
);
6237 defsubr (&Srecursive_edit
);
6239 defsubr (&Strack_mouse
);
6241 defsubr (&Sinput_pending_p
);
6242 defsubr (&Scommand_execute
);
6243 defsubr (&Srecent_keys
);
6244 defsubr (&Sthis_command_keys
);
6245 defsubr (&Ssuspend_emacs
);
6246 defsubr (&Sabort_recursive_edit
);
6247 defsubr (&Sexit_recursive_edit
);
6248 defsubr (&Srecursion_depth
);
6249 defsubr (&Stop_level
);
6250 defsubr (&Sdiscard_input
);
6251 defsubr (&Sopen_dribble_file
);
6252 defsubr (&Sset_input_mode
);
6253 defsubr (&Scurrent_input_mode
);
6254 defsubr (&Sexecute_extended_command
);
6256 DEFVAR_LISP ("last-command-char", &last_command_char
,
6257 "Last input event that was part of a command.");
6259 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
6260 "Last input event that was part of a command.");
6262 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
6263 "Last input event in a command, except for mouse menu events.\n\
6264 Mouse menus give back keys that don't look like mouse events;\n\
6265 this variable holds the actual mouse event that led to the menu,\n\
6266 so that you can determine whether the command was run by mouse or not.");
6268 DEFVAR_LISP ("last-input-char", &last_input_char
,
6269 "Last input event.");
6271 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
6272 "Last input event.");
6274 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
6275 "List of objects to be read as next command input events.");
6277 DEFVAR_INT ("unread-command-char", &unread_command_char
,
6278 "If not -1, an object to be read as next command input event.");
6280 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
6281 "Meta-prefix character code. Meta-foo as command input\n\
6282 turns into this character followed by foo.");
6283 XSETINT (meta_prefix_char
, 033);
6285 DEFVAR_LISP ("last-command", &last_command
,
6286 "The last command executed. Normally a symbol with a function definition,\n\
6287 but can be whatever was found in the keymap, or whatever the variable\n\
6288 `this-command' was set to by that command.\n\
6290 The value `mode-exit' is special; it means that the previous command\n\
6291 read an event that told it to exit, and it did so and unread that event.\n\
6292 In other words, the present command is the event that made the previous\n\
6295 The value `kill-region' is special; it means that the previous command\n\
6296 was a kill command.");
6297 last_command
= Qnil
;
6299 DEFVAR_LISP ("this-command", &this_command
,
6300 "The command now being executed.\n\
6301 The command can set this variable; whatever is put here\n\
6302 will be in `last-command' during the following command.");
6303 this_command
= Qnil
;
6305 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
6306 "*Number of keyboard input characters between auto-saves.\n\
6307 Zero means disable autosaving due to number of characters typed.");
6308 auto_save_interval
= 300;
6310 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
6311 "*Number of seconds idle time before auto-save.\n\
6312 Zero or nil means disable auto-saving due to idleness.\n\
6313 After auto-saving due to this many seconds of idle time,\n\
6314 Emacs also does a garbage collection if that seems to be warranted.");
6315 XSETFASTINT (Vauto_save_timeout
, 30);
6317 DEFVAR_INT ("echo-keystrokes", &echo_keystrokes
,
6318 "*Nonzero means echo unfinished commands after this many seconds of pause.");
6319 echo_keystrokes
= 1;
6321 DEFVAR_INT ("polling-period", &polling_period
,
6322 "*Interval between polling for input during Lisp execution.\n\
6323 The reason for polling is to make C-g work to stop a running program.\n\
6324 Polling is needed only when using X windows and SIGIO does not work.\n\
6325 Polling is automatically disabled in all other cases.");
6328 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
6329 "*Maximum time between mouse clicks to make a double-click.\n\
6330 Measured in milliseconds. nil means disable double-click recognition;\n\
6331 t means double-clicks have no time limit and are detected\n\
6332 by position only.");
6333 Vdouble_click_time
= make_number (500);
6335 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
6336 "*Non-nil means inhibit local map menu bar menus.");
6337 inhibit_local_menu_bar_menus
= 0;
6339 DEFVAR_INT ("num-input-keys", &num_input_keys
,
6340 "Number of complete keys read from the keyboard so far.");
6343 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
6344 "The frame in which the most recently read event occurred.\n\
6345 If the last event came from a keyboard macro, this is set to `macro'.");
6346 Vlast_event_frame
= Qnil
;
6348 DEFVAR_LISP ("help-char", &Vhelp_char
,
6349 "Character to recognize as meaning Help.\n\
6350 When it is read, do `(eval help-form)', and display result if it's a string.\n\
6351 If the value of `help-form' is nil, this char can be read normally.");
6352 XSETINT (Vhelp_char
, Ctl ('H'));
6354 DEFVAR_LISP ("help-form", &Vhelp_form
,
6355 "Form to execute when character `help-char' is read.\n\
6356 If the form returns a string, that string is displayed.\n\
6357 If `help-form' is nil, the help char is not recognized.");
6360 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
6361 "Command to run when `help-char' character follows a prefix key.\n\
6362 This command is used only when there is no actual binding\n\
6363 for that character after that prefix key.");
6364 Vprefix_help_command
= Qnil
;
6366 DEFVAR_LISP ("top-level", &Vtop_level
,
6367 "Form to evaluate when Emacs starts up.\n\
6368 Useful to set before you dump a modified Emacs.");
6371 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
6372 "String used as translate table for keyboard input, or nil.\n\
6373 Each character is looked up in this string and the contents used instead.\n\
6374 If string is of length N, character codes N and up are untranslated.");
6375 Vkeyboard_translate_table
= Qnil
;
6377 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
6378 "Keymap of key translations that can override keymaps.\n\
6379 This keymap works like `function-key-map', but comes after that,\n\
6380 and applies even for keys that have ordinary bindings.");
6381 Vkey_translation_map
= Qnil
;
6383 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
6384 "Non-nil means to always spawn a subshell instead of suspending,\n\
6385 even if the operating system has support for stopping a process.");
6388 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
6389 "Non-nil means prompt with menus when appropriate.\n\
6390 This is done when reading from a keymap that has a prompt string,\n\
6391 for elements that have prompt strings.\n\
6392 The menu is displayed on the screen\n\
6393 if X menus were enabled at configuration\n\
6394 time and the previous event was a mouse click prefix key.\n\
6395 Otherwise, menu prompting uses the echo area.");
6398 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
6399 "Character to see next line of menu prompt.\n\
6400 Type this character while in a menu prompt to rotate around the lines of it.");
6401 XSETINT (menu_prompt_more_char
, ' ');
6403 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
6404 "A mask of additional modifier keys to use with every keyboard character.\n\
6405 Emacs applies the modifiers of the character stored here to each keyboard\n\
6406 character it reads. For example, after evaluating the expression\n\
6407 (setq extra-keyboard-modifiers ?\\C-x)\n\
6408 all input characters will have the control modifier applied to them.\n\
6410 Note that the character ?\\C-@, equivalent to the integer zero, does\n\
6411 not count as a control character; rather, it counts as a character\n\
6412 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero\n\
6413 cancels any modification.");
6414 extra_keyboard_modifiers
= 0;
6416 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
6417 "If an editing command sets this to t, deactivate the mark afterward.\n\
6418 The command loop sets this to nil before each command,\n\
6419 and tests the value when the command returns.\n\
6420 Buffer modification stores t in this variable.");
6421 Vdeactivate_mark
= Qnil
;
6423 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
6424 "Temporary storage of pre-command-hook or post-command-hook.");
6425 Vcommand_hook_internal
= Qnil
;
6427 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
6428 "Normal hook run before each command is executed.\n\
6429 While the hook is run, its value is temporarily set to nil\n\
6430 to avoid an unbreakable infinite loop if a hook function gets an error.\n\
6431 As a result, a hook function cannot straightforwardly alter the value of\n\
6432 `pre-command-hook'. See the Emacs Lisp manual for a way of\n\
6433 implementing hook functions that alter the set of hook functions.");
6434 Vpre_command_hook
= Qnil
;
6436 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
6437 "Normal hook run after each command is executed.\n\
6438 While the hook is run, its value is temporarily set to nil\n\
6439 to avoid an unbreakable infinite loop if a hook function gets an error.\n\
6440 As a result, a hook function cannot straightforwardly alter the value of\n\
6441 `post-command-hook'. See the Emacs Lisp manual for a way of\n\
6442 implementing hook functions that alter the set of hook functions.");
6443 Vpost_command_hook
= Qnil
;
6445 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
6446 "t means menu bar, specified Lucid style, needs to be recomputed.");
6447 Vlucid_menu_bar_dirty_flag
= Qnil
;
6449 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
6450 "List of menu bar items to move to the end of the menu bar.\n\
6451 The elements of the list are event types that may have menu bar bindings.");
6452 Vmenu_bar_final_items
= Qnil
;
6454 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
6455 "Keymap that overrides all other local keymaps.\n\
6456 If this variable is non-nil, it is used as a keymap instead of the\n\
6457 buffer's local map, and the minor mode keymaps and text property keymaps.");
6458 Voverriding_local_map
= Qnil
;
6460 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
6461 "Non-nil means `overriding-local-map' applies to the menu bar.\n\
6462 Otherwise, the menu bar continues to reflect the buffer's local map\n\
6463 and the minor mode maps regardless of `overriding-local-map'.");
6464 Voverriding_local_map_menu_flag
= Qnil
;
6467 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
6468 "*Non-nil means generate motion events for mouse motion.");
6471 DEFVAR_LISP ("system-key-alist", &Vsystem_key_alist
,
6472 "Alist of system-specific X windows key symbols.\n\
6473 Each element should have the form (N . SYMBOL) where N is the\n\
6474 numeric keysym code (sans the \"system-specific\" bit 1<<28)\n\
6475 and SYMBOL is its name.");
6476 Vsystem_key_alist
= Qnil
;
6478 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
6479 "List of deferred actions to be performed at a later time.\n\
6480 The precise format isn't relevant here; we just check whether it is nil.");
6481 Vdeferred_action_list
= Qnil
;
6483 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
6484 "Function to call to handle deferred actions, after each command.\n\
6485 This function is called with no arguments after each command\n\
6486 whenever `deferred-action-list' is non-nil.");
6487 Vdeferred_action_function
= Qnil
;
6492 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
6493 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
6494 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
6495 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
6496 initial_define_key (meta_map
, 'x', "execute-extended-command");