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