![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keyboard.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / src|
Return to keyboard.c CVS log | Up to [Apple XNU] / GNUtools / emacs / src |
1.1 root 1: /* Keyboard input; editor command loop.
2: Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GNU Emacs is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU Emacs; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /*** For version 19, can simplify this by making interrupt_input 1 on VMS. */
21:
22: /* This must precede sys/signal.h on certain machines. */
23: #include <sys/types.h>
24: /* Allow config.h to undefine symbols found here. */
25: #include <signal.h>
26:
27: #include "config.h"
28: #include <stdio.h>
29: #undef NULL
30: #include "termchar.h"
31: #include "termopts.h"
32: #include "termhooks.h"
33: #include "lisp.h"
34: #include "macros.h"
35: #include "window.h"
36: #include "commands.h"
37: #include "buffer.h"
38: #include <setjmp.h>
39: #include <errno.h>
40:
41: extern int errno;
42:
43: /* Get FIONREAD, if it is available. */
44: #ifdef USG
45: #include <termio.h>
46: #include <fcntl.h>
47: #else /* not USG */
48: #ifndef VMS
49: #include <sys/ioctl.h>
50: #endif /* not VMS */
51: #endif /* not USG */
52:
53: #include "emacssignal.h"
54:
55: /* Allow m- file to inhibit use of FIONREAD. */
56: #ifdef BROKEN_FIONREAD
57: #undef FIONREAD
58: #endif
59:
60: /* Make all keyboard buffers much bigger when using X windows. */
61: #ifdef HAVE_X_WINDOWS
62: #define BUFFER_SIZE_FACTOR 16
63: #else
64: #define BUFFER_SIZE_FACTOR 1
65: #endif
66:
67: /* Following definition copied from eval.c */
68:
69: struct backtrace
70: {
71: struct backtrace *next;
72: Lisp_Object *function;
73: Lisp_Object *args; /* Points to vector of args. */
74: int nargs; /* length of vector */
75: /* if nargs is UNEVALLED, args points to slot holding list of unevalled args */
76: char evalargs;
77: };
78:
79: /* Non-nil disable property on a command means
80: do not execute it; call disabled-command-hook's value instead. */
81: Lisp_Object Qdisabled, Vdisabled_command_hook;
82:
83: int recent_keys_index; /* Index for storing next element into recent_keys */
84: int total_keys; /* Total number of elements stored into recent_keys */
85: char recent_keys[100]; /* Holds last 100 keystrokes */
86:
87: /* Buffer holding the key that invoked the current command. */
88: unsigned char *this_command_keys;
89: int this_command_key_count; /* Size in use. */
90: int this_command_keys_size; /* Size allocated. */
91:
92: extern struct backtrace *backtrace_list;
93:
94: static jmp_buf getcjmp; /* for longjmp to where kbd input is being done. */
95:
96: int waiting_for_input; /* True while doing kbd input */
97:
98: /* True while displaying for echoing. Delays C-g throwing. */
99: static int echoing;
100:
101: int immediate_quit; /* Nonzero means C-G should cause immediate error-signal. */
102:
103: int help_char; /* Character to recognize as the help char. */
104:
105: Lisp_Object Vhelp_form; /* Form to execute when help char is typed. */
106:
107: /* Character that causes a quit. Normally C-g. */
108:
109: int quit_char;
110:
111: extern Lisp_Object global_map;
112:
113: /* Current depth in recursive edits. */
114:
115: int command_loop_level;
116:
117: /* Last input character read as a command. */
118:
119: int last_command_char;
120:
121: /* Last input character read for any purpose. */
122:
123: int last_input_char;
124:
125: /* If not -1, a character to be read as the next command input */
126:
127: int unread_command_char;
128:
129: /* Char to use as prefix when a meta character is typed in.
130: This is bound on entry to minibuffer in case Esc is changed there. */
131:
132: int meta_prefix_char;
133:
134: /* Total number of times read_command_char has returned. */
135:
136: int num_input_chars;
137:
138: /* Auto-save automatically when this many characters have been typed
139: since the last time. */
140:
141: static int auto_save_interval;
142:
143: /* Value of num_input_chars as of last auto save. */
144:
145: int last_auto_save;
146:
147: /* Last command executed by the editor command loop, not counting
148: commands that set the prefix argument. */
149:
150: Lisp_Object last_command;
151:
152: /* The command being executed by the command loop.
153: Commands may set this, and the value set will be copied into last_command
154: instead of the actual command. */
155: Lisp_Object this_command;
156:
157: Lisp_Object Qself_insert_command;
158: Lisp_Object Qforward_char;
159: Lisp_Object Qbackward_char;
160:
161: /* read_key_sequence stores here the command definition of the
162: key sequence that it reads. */
163: Lisp_Object read_key_sequence_cmd;
164:
165: /* Form to evaluate (if non-nil) when Emacs is started */
166: Lisp_Object Vtop_level;
167:
168: /* User-supplied string to translate input characters through */
169: Lisp_Object Vkeyboard_translate_table;
170:
171: FILE *dribble; /* File in which we write all commands we read */
172:
173: /* Nonzero if input is available */
174: int input_pending;
175:
176: /* Nonzero if should obey 0200 bit in input chars as "Meta" */
177: int meta_key;
178:
179: extern char *pending_malloc_warning;
180:
181: /* Buffer for pre-read keyboard input */
182: unsigned char kbd_buffer [256 * BUFFER_SIZE_FACTOR];
183:
184: /* Number of characters available in kbd_buffer. */
185: int kbd_count;
186:
187: /* Pointer to next available character in kbd_buffer. */
188: unsigned char *kbd_ptr;
189:
190: /* Address (if not 0) of word to zero out
191: if a SIGIO interrupt happens */
192: long *input_available_clear_word;
193:
194: /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
195: Default is 1 if INTERRUPT_INPUT is defined. */
196:
197: int interrupt_input;
198:
199: /* Nonzero while interrupts are temporarily deferred during redisplay. */
200:
201: int interrupts_deferred;
202:
203: /* nonzero means use ^S/^Q for flow control. */
204:
205: int flow_control;
206:
207: #ifndef BSD4_1
208: #define sigfree() sigsetmask (SIGEMPTYMASK)
209: #define sigholdx(sig) sigsetmask (sigmask (sig))
210: #define sigblockx(sig) sigblock (sigmask (sig))
211: #define sigunblockx(sig) sigblock (SIGEMPTYMASK)
212: #define sigpausex(sig) sigpause (0)
213: #endif /* not BSD4_1 */
214:
215: #ifdef BSD4_1
216: #define SIGIO SIGTINT
217: /* sigfree and sigholdx are in sysdep.c */
218: #define sigblockx(sig) sighold (sig)
219: #define sigunblockx(sig) sigrelse (sig)
220: #define sigpausex(sig) sigpause (sig)
221: #endif /* BSD4_1 */
222:
223: /* We are unable to use interrupts if FIONREAD is not available,
224: so flush SIGIO so we won't try. */
225: #ifndef FIONREAD
226: #ifdef SIGIO
227: #undef SIGIO
228: #endif
229: #endif
230:
231: /* If we support X Windows, and won't get an interrupt when input
232: arrives from the server, poll periodically so we can detect C-g. */
233: #ifdef HAVE_X_WINDOWS
234: #ifndef SIGIO
235: #define POLL_FOR_INPUT
236: #endif
237: #endif
238:
239: /* Function for init_keyboard to call with no args (if nonzero). */
240: void (*keyboard_init_hook) ();
241:
242: static void read_avail_input ();
243: static void get_input_pending ();
244:
245: /* Non-zero tells input_available_signal to call read_socket_hook
246: even if FIONREAD returns zero. */
247: static int force_input;
248:
249: static int echo_keystrokes; /* > 0 if we are to echo keystrokes */
250:
251: /* Nonzero means echo each character as typed. */
252: static int immediate_echo;
253:
254: #define min(a,b) ((a)<(b)?(a):(b))
255: #define max(a,b) ((a)>(b)?(a):(b))
256:
257: static char echobuf[100];
258: static char *echoptr;
259:
260: /* Install the string STR as the beginning of the string of echoing,
261: so that it serves as a prompt for the next character.
262: Also start echoing. */
263:
264: echo_prompt (str)
265: char *str;
266: {
267: int len = strlen (str);
268: if (len > sizeof echobuf - 4)
269: len = sizeof echobuf - 4;
270: bcopy (str, echobuf, len + 1);
271: echoptr = echobuf + len;
272:
273: echo ();
274: }
275:
276: /* Add the character C to the echo string,
277: if echoing is going on. */
278:
279: echo_char (c)
280: int c;
281: {
282: extern char *push_key_description ();
283:
284: if (immediate_echo)
285: {
286: char *ptr = echoptr;
287:
288: if (ptr - echobuf > sizeof echobuf - 6)
289: return;
290:
291: if (echoptr != echobuf)
292: *ptr++ = ' ';
293:
294: ptr = push_key_description (c, ptr);
295: if (echoptr == echobuf && c == help_char)
296: {
297: strcpy (ptr, " (Type ? for further options)");
298: ptr += strlen (ptr);
299: }
300:
301: *ptr = 0;
302: echoptr = ptr;
303:
304: echo ();
305: }
306: }
307:
308: /* Temporarily add a dash to the end of the echo string,
309: so that it serves as a mini-prompt for the very next character. */
310:
311: echo_dash ()
312: {
313: if (!immediate_echo && echoptr == echobuf)
314: return;
315:
316: /* Put a dash at the end of the buffer temporarily,
317: but make it go away when the next character is added. */
318: echoptr[0] = '-';
319: echoptr[1] = 0;
320:
321: echo ();
322: }
323:
324: /* Display the current echo string, and begin echoing if not already
325: doing so. */
326:
327: echo ()
328: {
329: if (!immediate_echo)
330: {
331: int i;
332: immediate_echo = 1;
333:
334: for (i = 0; i < this_command_key_count; i++)
335: echo_char (this_command_keys[i]);
336: echo_dash ();
337: }
338:
339: echoing = 1;
340: message1 (echobuf);
341: echoing = 0;
342:
343: if (waiting_for_input && !NULL (Vquit_flag))
344: quit_throw_to_read_command_char ();
345: }
346:
347: /* Turn off echoing, for the start of a new command. */
348:
349: cancel_echoing ()
350: {
351: immediate_echo = 0;
352: echoptr = echobuf;
353: }
354:
355: /* When an auto-save happens, record the "time", and don't do again soon. */
356: record_auto_save ()
357: {
358: last_auto_save = num_input_chars;
359: }
360:
361: Lisp_Object recursive_edit_unwind (), command_loop ();
362:
363: DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
364: "Invoke the editor command loop recursively.\n\
365: Do (throw 'exit nil) within the command loop to make this function return,\n\
366: or (throw 'exit t) to make this function signal an error.\n\
367: This function is called by the editor initialization\n\
368: to begin editing.")
369: ()
370: {
371: int count = specpdl_ptr - specpdl;
372:
373: command_loop_level++;
374: update_mode_lines = 1;
375:
376: record_unwind_protect (recursive_edit_unwind,
377: (current_buffer != XBUFFER (XWINDOW (selected_window)->buffer)
378: ? Fcurrent_buffer ()
379: : Qnil));
380:
381: recursive_edit_1 ();
382:
383: unbind_to (count);
384: return Qnil;
385: }
386:
387: Lisp_Object
388: recursive_edit_1 ()
389: {
390: int count = specpdl_ptr - specpdl;
391: Lisp_Object val;
392:
393: if (command_loop_level > 0)
394: {
395: specbind (Qstandard_output, Qt);
396: specbind (Qstandard_input, Qt);
397: }
398:
399: val = command_loop ();
400: if (EQ (val, Qt))
401: Fsignal (Qquit, Qnil);
402:
403: unbind_to (count);
404: return Qnil;
405: }
406:
407: Lisp_Object
408: recursive_edit_unwind (buffer)
409: Lisp_Object buffer;
410: {
411: if (!NULL (buffer))
412: Fset_buffer (buffer);
413: command_loop_level--;
414: update_mode_lines = 1;
415: return Qnil;
416: }
417:
418: Lisp_Object
419: cmd_error (data)
420: Lisp_Object data;
421: {
422: Lisp_Object errmsg, tail, errname, file_error;
423: struct gcpro gcpro1;
424: int i;
425:
426: Vquit_flag = Qnil;
427: Vinhibit_quit = Qt;
428: Vstandard_output = Qt;
429: Vstandard_input = Qt;
430: Vexecuting_macro = Qnil;
431: echo_area_contents = 0;
432:
433: Fdiscard_input ();
434: bell ();
435:
436: errname = Fcar (data);
437:
438: if (EQ (errname, Qerror))
439: {
440: data = Fcdr (data);
441: if (!CONSP (data)) data = Qnil;
442: errmsg = Fcar (data);
443: file_error = Qnil;
444: }
445: else
446: {
447: errmsg = Fget (errname, Qerror_message);
448: file_error = Fmemq (Qfile_error,
449: Fget (errname, Qerror_conditions));
450: }
451:
452: /* Print an error message including the data items.
453: This is done by printing it into a scratch buffer
454: and then making a copy of the text in the buffer. */
455:
456: if (!CONSP (data)) data = Qnil;
457: tail = Fcdr (data);
458: GCPRO1 (tail);
459:
460: /* For file-error, make error message by concatenating
461: all the data items. They are all strings. */
462: if (!NULL (file_error))
463: errmsg = XCONS (tail)->car, tail = XCONS (tail)->cdr;
464:
465: if (XTYPE (errmsg) == Lisp_String)
466: Fprinc (errmsg, Qt);
467: else
468: write_string_1 ("peculiar error", -1, Qt);
469:
470: for (i = 0; CONSP (tail); tail = Fcdr (tail), i++)
471: {
472: write_string_1 (i ? ", " : ": ", 2, Qt);
473: if (!NULL (file_error))
474: Fprinc (Fcar (tail), Qt);
475: else
476: Fprin1 (Fcar (tail), Qt);
477: }
478: UNGCPRO;
479:
480: /* In -batch mode, force out the error message and newlines after it
481: and then die. */
482: if (noninteractive)
483: {
484: message ("");
485: Fkill_emacs (make_number (-1));
486: }
487:
488: Vquit_flag = Qnil;
489:
490: Vinhibit_quit = Qnil;
491: return make_number (0);
492: }
493:
494: Lisp_Object command_loop_1 ();
495: Lisp_Object command_loop_2 ();
496: Lisp_Object cmd_error ();
497: Lisp_Object top_level_1 ();
498:
499: /* Entry to editor-command-loop.
500: This level has the catches for exiting/returning to editor command loop.
501: It returns nil to exit recursive edit, t to abort it. */
502:
503: Lisp_Object
504: command_loop ()
505: {
506: if (command_loop_level > 0 || minibuf_level > 0)
507: {
508: return internal_catch (Qexit, command_loop_2, Qnil);
509: }
510: else
511: while (1)
512: {
513: internal_catch (Qtop_level, top_level_1, Qnil);
514: internal_catch (Qtop_level, command_loop_2, Qnil);
515: /* End of file in -batch run causes exit here. */
516: if (noninteractive)
517: Fkill_emacs (Qt);
518: }
519: }
520:
521: /* Here we catch errors in execution of commands within the
522: editing loop, and reenter the editing loop.
523: When there is an error, cmd_error runs and returns a non-nil
524: value to us. A value of nil means that cmd_loop_1 itself
525: returned due to end of file (or end of kbd macro). */
526:
527: Lisp_Object
528: command_loop_2 ()
529: {
530: register Lisp_Object val;
531: do
532: val = internal_condition_case (command_loop_1, Qerror, cmd_error);
533: while (!NULL (val));
534: return Qnil;
535: }
536:
537: Lisp_Object
538: top_level_2 ()
539: {
540: return Feval (Vtop_level);
541: }
542:
543: Lisp_Object
544: top_level_1 ()
545: {
546: /* On entry to the outer level, run the startup file */
547: if (!NULL (Vtop_level))
548: internal_condition_case (top_level_2, Qerror, cmd_error);
549: else if (!NULL (Vpurify_flag))
550: message ("Bare impure Emacs (standard Lisp code not loaded)");
551: else
552: message ("Bare Emacs (standard Lisp code not loaded)");
553: return Qnil;
554: }
555:
556: DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
557: "Exit all recursive editing levels.")
558: ()
559: {
560: Fthrow (Qtop_level, Qnil);
561: }
562:
563: DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
564: "Exit from the innermost recursive edit or minibuffer.")
565: ()
566: {
567: if (command_loop_level > 0 || minibuf_level > 0)
568: Fthrow (Qexit, Qnil);
569: error ("No recursive edit is in progress");
570: }
571:
572: DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
573: "Abort the command that requested this recursive edit or minibuffer input.")
574: ()
575: {
576: if (command_loop_level > 0 || minibuf_level > 0)
577: Fthrow (Qexit, Qt);
578: error ("No recursive edit is in progress");
579: }
580:
581: /* This is the actual command reading loop,
582: sans error-handling encapsulation */
583:
584: Lisp_Object Fcommand_execute ();
585:
586: Lisp_Object
587: command_loop_1 ()
588: {
589: Lisp_Object cmd;
590: int lose;
591: int nonundocount;
592: char keybuf[30];
593: int i;
594: int no_redisplay;
595: int no_direct;
596:
597: Vprefix_arg = Qnil;
598: waiting_for_input = 0;
599: cancel_echoing ();
600:
601: /* Don't clear out last_command at the beginning of a macro. */
602: if (NULL (Vexecuting_macro)
603: || XTYPE (Vexecuting_macro) != Lisp_String)
604: last_command = Qt;
605: nonundocount = 0;
606: no_redisplay = 0;
607: this_command_key_count = 0;
608:
609: while (1)
610: {
611: /* Install chars successfully executed in kbd macro */
612: if (defining_kbd_macro && NULL (Vprefix_arg))
613: finalize_kbd_macro_chars ();
614:
615: /* Make sure current window's buffer is selected. */
616:
617: if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
618: set_buffer_internal (XBUFFER (XWINDOW (selected_window)->buffer));
619:
620: /* Display any malloc warning that just came out.
621: Use while because displaying one warning can cause another. */
622: while (pending_malloc_warning)
623: display_malloc_warning ();
624:
625: no_direct = 0;
626:
627: /* If minibuffer on and echo area in use,
628: wait 2 sec and redraw minibufer. */
629:
630: if (minibuf_level && echo_area_contents)
631: {
632: int count = specpdl_ptr - specpdl;
633: specbind (Qinhibit_quit, Qt);
634: Fsit_for (make_number (2), Qnil);
635: unbind_to (count);
636:
637: echo_area_contents = 0;
638: no_direct = 1;
639: if (!NULL (Vquit_flag))
640: {
641: Vquit_flag = Qnil;
642: unread_command_char = quit_char;
643: }
644: }
645:
646: i = 0;
647: #if 0
648: /* If prev. command was directly displayed, we don't need
649: redisplay. Try shortcut for reading single-char key sequence. */
650: if (no_redisplay)
651: i = fast_read_one_key (keybuf);
652: #endif /* 0 */
653: /* Shortcut not applicable or found a prefix key.
654: Take full precautions and read key sequence the hard way. */
655: if (i == 0)
656: {
657: #ifdef C_ALLOCA
658: alloca (0); /* Cause a garbage collection now */
659: /* Since we can free the most stuff here. */
660: #endif /* C_ALLOCA */
661:
662: /* Read next key sequence; i gets its length. */
663:
664: i = read_key_sequence (keybuf, sizeof keybuf, 0,
665: no_redisplay && buffer_shared <= 1);
666: }
667:
668: /* Now we have read a key sequence of length I,
669: or else I is 0 and we found end of file. */
670:
671: if (i == 0) /* End of file -- happens only in */
672: return Qnil; /* a kbd macro, at the end */
673:
674: last_command_char = keybuf[i - 1];
675:
676: cmd = read_key_sequence_cmd;
677: if (!NULL (Vexecuting_macro))
678: {
679: if (!NULL (Vquit_flag))
680: {
681: Vexecuting_macro = Qt;
682: QUIT; /* Make some noise. */
683: /* Will return since macro now empty. */
684: }
685: }
686:
687: /* Do redisplay processing after this command except in special
688: cases identified below that set no_redisplay to 1. */
689: no_redisplay = 0;
690:
691: /* Execute the command. */
692:
693: if (NULL (cmd))
694: {
695: /* nil means key is undefined. */
696: bell ();
697: defining_kbd_macro = 0;
698: update_mode_lines++;
699: Vprefix_arg = Qnil;
700: }
701: else
702: {
703: this_command = cmd;
704: if (NULL (Vprefix_arg) && ! no_direct)
705: {
706: if (EQ (cmd, Qforward_char) && point < ZV)
707: {
708: lose = FETCH_CHAR (point);
709: SET_PT (point + 1);
710: if (lose >= ' ' && lose < 0177
711: && (XFASTINT (XWINDOW (selected_window)->last_modified)
712: >= MODIFF)
713: && (XFASTINT (XWINDOW (selected_window)->last_point)
714: == point)
715: && !windows_or_buffers_changed
716: && EQ (current_buffer->selective_display, Qnil)
717: && !detect_input_pending ()
718: && NULL (Vexecuting_macro))
719: no_redisplay = direct_output_forward_char (1);
720: goto directly_done;
721: }
722: else if (EQ (cmd, Qbackward_char) && point > BEGV)
723: {
724: SET_PT (point - 1);
725: lose = FETCH_CHAR (point);
726: if (lose >= ' ' && lose < 0177
727: && (XFASTINT (XWINDOW (selected_window)->last_modified)
728: >= MODIFF)
729: && (XFASTINT (XWINDOW (selected_window)->last_point)
730: == point)
731: && !windows_or_buffers_changed
732: && EQ (current_buffer->selective_display, Qnil)
733: && !detect_input_pending ()
734: && NULL (Vexecuting_macro))
735: no_redisplay = direct_output_forward_char (-1);
736: goto directly_done;
737: }
738: else if (EQ (cmd, Qself_insert_command))
739: {
740: if (NULL (Vexecuting_macro) &&
741: !EQ (minibuf_window, selected_window))
742: {
743: if (!nonundocount || nonundocount >= 20)
744: {
745: Fundo_boundary ();
746: nonundocount = 0;
747: }
748: nonundocount++;
749: }
750: lose = (XFASTINT (XWINDOW (selected_window)->last_modified)
751: < MODIFF)
752: || (XFASTINT (XWINDOW (selected_window)->last_point)
753: != point)
754: || MODIFF <= current_buffer->save_modified
755: || windows_or_buffers_changed
756: || !EQ (current_buffer->selective_display, Qnil)
757: || detect_input_pending ()
758: || !NULL (Vexecuting_macro);
759: if (self_insert_internal (last_command_char, 0))
760: {
761: lose = 1;
762: nonundocount = 0;
763: }
764: if (!lose
765: && (point == ZV || FETCH_CHAR (point) == '\n')
766: && last_command_char >= ' '
767: && last_command_char < 0177)
768: no_redisplay
769: = direct_output_for_insert (last_command_char);
770: goto directly_done;
771: }
772: }
773:
774: /* Here for a command that isn't executed directly */
775:
776: nonundocount = 0;
777: if (NULL (Vprefix_arg))
778: Fundo_boundary ();
779: Fcommand_execute (cmd, Qnil);
780: }
781: /* This label logically belongs inside the above group,
782: but moving it is said to avoid a compiler bug on SCO V.3.2v2. */
783: directly_done: ;
784:
785: if (NULL (Vprefix_arg))
786: {
787: last_command = this_command;
788: this_command_key_count = 0;
789: cancel_echoing ();
790: }
791: }
792: }
793:
794: /* Input of single characters from keyboard */
795:
796: Lisp_Object print_help ();
797:
798: int echo_flag;
799: int echo_now;
800:
801: /* Alarm interrupt calls this and requests echoing at earliest safe time. */
802: request_echo ()
803: {
804: int old_errno = errno;
805:
806: /* Note: no need to reestablish handler on USG systems
807: because it is established, if approriate, each time an alarm is requested. */
808: #ifdef subprocesses
809: #ifdef BSD4_1
810: extern int select_alarmed;
811: if (select_alarmed == 0)
812: {
813: select_alarmed = 1;
814: sigrelse (SIGALRM);
815: return;
816: }
817: #endif
818: #endif
819:
820: #ifdef BSD4_1
821: sigisheld (SIGALRM);
822: #endif
823:
824: if (echo_now)
825: echo ();
826: else
827: echo_flag = 1;
828:
829: #ifdef BSD4_1
830: sigunhold (SIGALRM);
831: #endif
832:
833: errno = old_errno;
834: }
835:
836: /* Nonzero means polling for input is temporarily suppresed. */
837: int poll_suppress_count;
838:
839: /* Number of seconds between polling for input. */
840: int polling_period;
841:
842: #ifdef POLL_FOR_INPUT
843: int polling_for_input;
844:
845: /* Handle an alarm once each second and read pending input
846: so as to handle a C-g if it comces in. */
847:
848: input_poll_signal ()
849: {
850: int junk;
851:
852: if (!waiting_for_input)
853: read_avail_input (&junk);
854: signal (SIGALRM, input_poll_signal);
855: alarm (polling_period);
856: }
857:
858: #endif
859:
860: /* Begin signals to poll for input, if they are appropriate.
861: This function is called unconditionally from various places. */
862:
863: start_polling ()
864: {
865: #ifdef POLL_FOR_INPUT
866: if (read_socket_hook)
867: {
868: poll_suppress_count--;
869: if (poll_suppress_count == 0)
870: {
871: signal (SIGALRM, input_poll_signal);
872: polling_for_input = 1;
873: alarm (polling_period);
874: }
875: }
876: #endif
877: }
878:
879: /* Turn off polling. */
880:
881: stop_polling ()
882: {
883: #ifdef POLL_FOR_INPUT
884: if (read_socket_hook)
885: {
886: if (poll_suppress_count == 0)
887: {
888: polling_for_input = 0;
889: alarm (0);
890: }
891: poll_suppress_count++;
892: }
893: #endif
894: }
895:
896: /* read a character from the keyboard; call the redisplay if needed */
897: /* commandflag 0 means do not do auto-saving, but do do redisplay.
898: -1 means do not do redisplay, but do do autosaving.
899: 1 means do both. */
900:
901: read_command_char (commandflag)
902: int commandflag;
903: {
904: register int c;
905: int alarmtime;
906: int count;
907: Lisp_Object tem;
908: jmp_buf save_jump;
909: extern request_echo ();
910:
911: if (unread_command_char >= 0)
912: {
913: c = unread_command_char;
914: unread_command_char = -1;
915: if (this_command_key_count == 0)
916: goto reread_first;
917: goto reread;
918: }
919:
920: if (!NULL (Vexecuting_macro))
921: {
922: if (XTYPE (Vexecuting_macro) != Lisp_String
923: || XSTRING (Vexecuting_macro)->size <= executing_macro_index)
924: return -1;
925: QUIT;
926: c = XSTRING (Vexecuting_macro)->data[executing_macro_index++];
927: goto from_macro;
928: }
929:
930: /* Save outer setjmp data, in case called recursively. */
931: bcopy (getcjmp, save_jump, sizeof getcjmp);
932:
933: stop_polling ();
934:
935: if (commandflag >= 0 && !detect_input_pending ())
936: redisplay ();
937:
938: if (commandflag != 0
939: && auto_save_interval > 0
940: && num_input_chars - last_auto_save > max (auto_save_interval, 20)
941: && !detect_input_pending ())
942: Fdo_auto_save (Qnil);
943:
944: if (_setjmp (getcjmp))
945: {
946: c = quit_char;
947: waiting_for_input = 0;
948: input_available_clear_word = 0;
949:
950: goto non_reread;
951: }
952:
953: /* Message turns off echoing unless more keystrokes turn it on again. */
954: if (echo_area_contents && *echo_area_contents && echo_area_contents != echobuf)
955: cancel_echoing ();
956: else
957: /* If already echoing, continue, and prompt. */
958: echo_dash ();
959:
960: /* If in middle of key sequence and minibuffer not active,
961: start echoing if enough time elapses. */
962: if (minibuf_level == 0 && !immediate_echo && this_command_key_count > 0
963: && echo_keystrokes > 0
964: && (echo_area_contents == 0 || *echo_area_contents == 0))
965: {
966: /* Else start echoing if user waits more than `alarmtime' seconds. */
967: /* This interrupt either calls echo right away
968: or sets echo_flag, which causes echo to be called
969: by set_waiting_for_input's next invocation. */
970: signal (SIGALRM, request_echo);
971: echo_flag = 0;
972: echo_now = 0;
973: alarmtime = echo_keystrokes;
974: alarm ((unsigned) alarmtime);
975: }
976:
977: c = kbd_buffer_read_command_char ();
978:
979: /* Terminate Emacs in batch mode if at eof. */
980: if (noninteractive && c < 0)
981: Fkill_emacs (make_number (1));
982:
983: non_reread:
984:
985: bcopy (save_jump, getcjmp, sizeof getcjmp);
986:
987: /* Cancel alarm if it was set and has not already gone off. */
988: if (alarmtime > 0) alarm (0);
989:
990: echo_area_contents = 0;
991:
992: if (c < 0) return -1;
993:
994: c &= meta_key ? 0377 : 0177;
995:
996: if (XTYPE (Vkeyboard_translate_table) == Lisp_String
997: && XSTRING (Vkeyboard_translate_table)->size > c)
998: c = XSTRING (Vkeyboard_translate_table)->data[c];
999:
1000: total_keys++;
1001: recent_keys[recent_keys_index] = c;
1002: recent_keys_index = (recent_keys_index + 1) % sizeof recent_keys;
1003:
1004: if (dribble)
1005: {
1006: putc (c, dribble);
1007: fflush (dribble);
1008: }
1009:
1010: store_kbd_macro_char (c);
1011:
1012: start_polling ();
1013:
1014: from_macro:
1015: reread_first: /* Rereading a char and it is the first in a command. */
1016:
1017: echo_char (c);
1018:
1019: /* Record this character as part of the current key. */
1020: if (this_command_key_count == this_command_keys_size)
1021: {
1022: this_command_keys_size *= 2;
1023: this_command_keys
1024: = (unsigned char *) xrealloc (this_command_keys,
1025: this_command_keys_size);
1026: }
1027: this_command_keys[this_command_key_count++] = c;
1028:
1029: /* Rereading in the middle of a command. */
1030: reread:
1031:
1032: last_input_char = c;
1033:
1034: num_input_chars++;
1035:
1036: /* Process the help character specially if enabled */
1037: if (c == help_char && !NULL (Vhelp_form))
1038: {
1039: count = specpdl_ptr - specpdl;
1040:
1041: record_unwind_protect (Fset_window_configuration,
1042: Fcurrent_window_configuration ());
1043:
1044: tem = Feval (Vhelp_form);
1045: if (XTYPE (tem) == Lisp_String)
1046: internal_with_output_to_temp_buffer ("*Help*", print_help, tem);
1047:
1048: cancel_echoing ();
1049: c = read_command_char (0);
1050: /* Remove the help from the screen */
1051: unbind_to (count);
1052: redisplay ();
1053: if (c == 040)
1054: {
1055: cancel_echoing ();
1056: c = read_command_char (0);
1057: }
1058: }
1059:
1060: return c;
1061: }
1062:
1063: Lisp_Object
1064: print_help (object)
1065: Lisp_Object object;
1066: {
1067: Fprinc (object, Qnil);
1068: return Qnil;
1069: }
1070:
1071: /* Low level keyboard input.
1072: Read characters into kbd_buffer
1073: from which they are obtained by kbd_buffer_read_command_char. */
1074:
1075: /* Set this for debugging, to have a way to get out */
1076: int stop_character;
1077:
1078: /* Store a character obtained at interrupt level into kbd_buffer, fifo */
1079: kbd_buffer_store_char (c)
1080: register int c;
1081: {
1082: c &= 0377;
1083:
1084: if (c == quit_char
1085: || ((c == (0200 | quit_char)) && !meta_key))
1086: {
1087: interrupt_signal ();
1088: return;
1089: }
1090:
1091: if (c && c == stop_character)
1092: {
1093: sys_suspend ();
1094: return;
1095: }
1096:
1097: if (kbd_ptr != kbd_buffer)
1098: {
1099: bcopy (kbd_ptr, kbd_buffer, kbd_count);
1100: kbd_ptr = kbd_buffer;
1101: }
1102:
1103: if (kbd_count < sizeof kbd_buffer)
1104: {
1105: kbd_buffer[kbd_count++] = c;
1106: }
1107: }
1108:
1109: kbd_buffer_read_command_char ()
1110: {
1111: register int c;
1112:
1113: if (noninteractive)
1114: {
1115: c = getchar ();
1116: return c;
1117: }
1118:
1119: /* Either ordinary input buffer or C-g buffered means we can return. */
1120: while (!kbd_count)
1121: {
1122: if (!NULL (Vquit_flag))
1123: quit_throw_to_read_command_char ();
1124:
1125: /* One way or another, wait until input is available; then, if
1126: interrupt handlers have not read it, read it now. */
1127:
1128: #ifdef VMS
1129: wait_for_kbd_input ();
1130: #else
1131: /* Note SIGIO has been undef'd if FIONREAD is missing. */
1132: #ifdef SIGIO
1133: gobble_input ();
1134: #endif /* SIGIO */
1135: if (!kbd_count)
1136: {
1137: #ifdef subprocesses
1138: wait_reading_process_input (0, -1, 1);
1139: #else
1140: /* Note SIGIO has been undef'd if FIONREAD is missing. */
1141: #ifdef SIGIO
1142: if (interrupt_input)
1143: {
1144: sigblockx (SIGIO);
1145: set_waiting_for_input (0);
1146: while (!kbd_count)
1147: sigpausex (SIGIO);
1148: clear_waiting_for_input ();
1149: sigunblockx (SIGIO);
1150: }
1151: #else
1152: interrupt_input = 0;
1153: #endif /* not SIGIO */
1154: #endif /* subprocesses */
1155:
1156: if (!interrupt_input && !kbd_count)
1157: {
1158: read_avail_input (0);
1159: }
1160: }
1161: #endif /* not VMS */
1162: }
1163:
1164: input_pending = --kbd_count > 0;
1165: c = *kbd_ptr; /* *kbd_ptr++ would have a timing error. */
1166: kbd_ptr++; /* See kbd_buffer_store_char. */
1167: return (c & (meta_key ? 0377 : 0177)); /* Clean up if sign was extended. */
1168: }
1169:
1170: /* Force an attempt to read input regardless of what FIONREAD says. */
1171:
1172: force_input_read ()
1173: {
1174: force_input = 1;
1175: detect_input_pending ();
1176: force_input = 0;
1177: }
1178:
1179: /* Store into *addr the number of terminal input chars available.
1180: Equivalent to ioctl (0, FIONREAD, addr) but works
1181: even if FIONREAD does not exist. */
1182:
1183: static void
1184: get_input_pending (addr)
1185: int *addr;
1186: {
1187: #ifdef VMS
1188: /* On VMS, we always have something in the buffer
1189: if any input is available. */
1190: /*** It might be simpler to make interrupt_input 1 on VMS ***/
1191: *addr = kbd_count | !NULL (Vquit_flag);
1192: #else
1193: /* First of all, have we already counted some input? */
1194: *addr = kbd_count | !NULL (Vquit_flag);
1195: /* If input is being read as it arrives, and we have none, there is none. */
1196: if (*addr > 0 || (interrupt_input && ! interrupts_deferred && ! force_input))
1197: return;
1198: #ifdef FIONREAD
1199: if (! force_input)
1200: {
1201: /* If we can count the input without reading it, do so. */
1202: if (ioctl (0, FIONREAD, addr) < 0)
1203: *addr = 0;
1204: if (*addr == 0 || read_socket_hook == 0)
1205: return;
1206: /* If the input consists of window-events, not all of them
1207: are necessarily kbd chars. So process all the input
1208: and see how many kbd chars we got. */
1209: }
1210: #endif
1211: #ifdef SIGIO
1212: {
1213: /* It seems there is a timing error such that a SIGIO can be handled here
1214: and cause kbd_count to become nonzero even though raising of SIGIO
1215: has already been turned off. */
1216: SIGMASKTYPE mask = sigblock (sigmask (SIGIO));
1217: if (kbd_count == 0)
1218: read_avail_input (*addr);
1219: sigsetmask (mask);
1220: }
1221: #else
1222: /* If we can't count the input, read it (if any) and see what we got. */
1223: read_avail_input (*addr);
1224: #endif
1225: *addr = kbd_count | !NULL (Vquit_flag);
1226: #endif
1227: }
1228:
1229: /* Read pending any input out of the system and into Emacs. */
1230:
1231: /* This function is temporary in Emacs 18. It is used only
1232: with X windows. X windows always turns on interrupt input
1233: if possible, so this function has nothing to do except
1234: on systems that don't have SIGIO. And they also don't have FIONREAD. */
1235: void
1236: consume_available_input ()
1237: {
1238: #ifdef SIGIO
1239: if (!interrupt_input || interrupts_deferred)
1240: #endif
1241: read_avail_input (0);
1242: }
1243:
1244: /* Read any terminal input already buffered up by the system
1245: into the kbd_buffer, assuming the buffer is currently empty.
1246: Never waits.
1247:
1248: If NREAD is nonzero, assume it contains # chars of raw data waiting.
1249: If it is zero, we determine that datum.
1250:
1251: Input gets into the kbd_buffer either through this function
1252: (at main program level) or at interrupt level if input
1253: is interrupt-driven. */
1254:
1255: static void
1256: read_avail_input (nread)
1257: int nread;
1258: {
1259: /* This function is not used on VMS. */
1260: #ifndef VMS
1261: char buf[256 * BUFFER_SIZE_FACTOR];
1262: register int i;
1263:
1264: #ifdef FIONREAD
1265: if (! force_input)
1266: {
1267: if (nread == 0)
1268: get_input_pending (&nread);
1269: if (nread == 0)
1270: return;
1271: }
1272: if (nread > sizeof buf)
1273: nread = sizeof buf;
1274:
1275: /* Read what is waiting. */
1276: if (read_socket_hook)
1277: nread = (*read_socket_hook) (0, buf, nread);
1278: else
1279: nread = read (0, buf, nread);
1280:
1281: #else /* no FIONREAD */
1282: #ifdef USG
1283: #ifdef SYSV_STREAMS
1284: /* When talking to Xwindows using streams, something gets screwed up
1285: if Emacs alters this flag in the descriptor. */
1286: if (!read_socket_hook)
1287: #endif
1288: fcntl (fileno (stdin), F_SETFL, O_NDELAY);
1289: if (read_socket_hook)
1290: {
1291: nread = (*read_socket_hook) (0, buf, sizeof buf);
1292: }
1293: else
1294: {
1295: nread = read (fileno (stdin), buf, sizeof buf);
1296: }
1297: #ifdef AIX
1298: /* The kernel sometimes fails to deliver SIGHUP for ptys.
1299: This looks incorrect, but it isn't, because _BSD causes
1300: O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
1301: and that causes a value other than 0 when there is no input. */
1302: if (nread == 0)
1303: kill (SIGHUP, 0);
1304: #endif
1305: #ifdef EBADSLT
1306: if (nread == -1 && (errno == EAGAIN || errno == EBADSLT))
1307: #else
1308: if (nread == -1 && errno == EAGAIN)
1309: #endif
1310: nread = 0;
1311: #ifdef SYSV_STREAMS
1312: if (!read_socket_hook)
1313: #endif
1314: fcntl (fileno (stdin), F_SETFL, 0);
1315: #else /* not USG */
1316: you lose
1317: #endif /* not USG */
1318: #endif /* no FIONREAD */
1319:
1320: /* Scan the chars for C-g and store them in kbd_buffer. */
1321: if (kbd_count == 0)
1322: kbd_ptr = kbd_buffer;
1323:
1324: for (i = 0; i < nread; i++)
1325: {
1326: kbd_buffer_store_char (buf[i]);
1327: /* Don't look at input that follows a C-g too closely.
1328: This reduces lossage due to autorepeat on C-g. */
1329: if (buf[i] == quit_char)
1330: break;
1331: }
1332: #endif /* not VMS */
1333: }
1334:
1335: #ifdef SIGIO /* for entire page */
1336: /* Note SIGIO has been undef'd if FIONREAD is missing. */
1337:
1338: /* If using interrupt input and some input chars snuck into the
1339: buffer before we enabled interrupts, fake an interrupt for them. */
1340:
1341: gobble_input ()
1342: {
1343: int nread;
1344: if (interrupt_input)
1345: {
1346: if (ioctl (0, FIONREAD, &nread) < 0)
1347: nread = 0;
1348: if (nread)
1349: {
1350: sigholdx (SIGIO);
1351: input_available_signal (SIGIO);
1352: sigfree ();
1353: }
1354: }
1355: }
1356:
1357: input_available_signal (signo)
1358: int signo;
1359: {
1360: unsigned char buf[256 * BUFFER_SIZE_FACTOR];
1361: int nread;
1362: register int i;
1363: /* Must preserve main program's value of errno. */
1364: int old_errno = errno;
1365: #ifdef BSD4_1
1366: extern int select_alarmed;
1367: #endif
1368:
1369: #ifdef USG
1370: /* USG systems forget handlers when they are used;
1371: must reestablish each time */
1372: signal (signo, input_available_signal);
1373: #endif /* USG */
1374:
1375: #ifdef BSD4_1
1376: sigisheld (SIGIO);
1377: #endif
1378:
1379: if (input_available_clear_word)
1380: *input_available_clear_word = 0;
1381:
1382: while (1)
1383: {
1384: if (ioctl (0, FIONREAD, &nread) < 0)
1385: /* Formerly simply exited the loop, but that sometimes led to
1386: a failure of Emacs to terminate.
1387: SIGHUP seems appropriate if we can't reach the terminal. */
1388: kill (getpid (), SIGHUP);
1389: if (nread <= 0)
1390: break;
1391: #ifdef BSD4_1
1392: select_alarmed = 1; /* Force the select emulator back to life */
1393: #endif
1394: if (read_socket_hook)
1395: {
1396: nread = (*read_socket_hook) (0, buf, sizeof buf);
1397: if (!nread)
1398: continue;
1399: }
1400: else
1401: {
1402: if (nread > sizeof buf)
1403: nread = sizeof buf;
1404: nread = read (0, buf, nread);
1405: }
1406:
1407: for (i = 0; i < nread; i++)
1408: {
1409: kbd_buffer_store_char (buf[i]);
1410: /* Don't look at input that follows a C-g too closely.
1411: This reduces lossage due to autorepeat on C-g. */
1412: if (buf[i] == quit_char)
1413: break;
1414: }
1415: }
1416: #ifdef BSD4_1
1417: sigfree ();
1418: #endif
1419: errno = old_errno;
1420: }
1421: #endif /* SIGIO */
1422:
1423: #if 0
1424: /* This is turned off because it didn't produce much speedup. */
1425:
1426: /* Read a single-char key sequence. Do not redisplay.
1427: Return 1 if successful, or 0 if what follows is not
1428: a single-char key. (In that case, a char has been unread.)
1429: This is used instead of read_key_sequence as an optimization
1430: just after a direct-updating command is done, since at such
1431: times we know that no redisplay is required. */
1432:
1433: int
1434: fast_read_one_key (keybuf)
1435: char *keybuf;
1436: {
1437: register Lisp_Object map;
1438: register int c;
1439: register Lisp_Object tem;
1440:
1441: keys_prompt = 0;
1442: /* Read a character, and do not redisplay. */
1443: c = read_command_char (-1);
1444: Vquit_flag = Qnil;
1445:
1446: /* Assume until further notice that we are unlucky
1447: and will return zero, so this char will be
1448: reread by read_key_sequence. */
1449:
1450: unread_command_char = c;
1451:
1452: if (c < 0 || c >= 0200)
1453: return 0;
1454:
1455: map = current_buffer->keymap;
1456: if (!EQ (map, Qnil))
1457: {
1458: tem = get_keyelt (access_keymap (map, c));
1459: if (!EQ (tem, Qnil))
1460: return 0;
1461: }
1462:
1463: XSET (map, Lisp_Vector, global_map);
1464: tem = !NULL (map)
1465: ? get_keyelt (access_keymap (map, c))
1466: : Qnil;
1467:
1468: read_key_sequence_cmd = tem;
1469:
1470: /* trace symbols to their function definitions */
1471:
1472: while (XTYPE (tem) == Lisp_Symbol && !NULL (tem)
1473: && !EQ (tem, Qunbound))
1474: tem = XSYMBOL (tem)->function;
1475:
1476: /* Is the definition a prefix character? */
1477:
1478: if (XTYPE (tem) == Lisp_Vector ||
1479: (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap)))
1480: return 0;
1481:
1482: unread_command_char = -1;
1483: keybuf[0] = c;
1484: return 1;
1485: }
1486:
1487: #endif /* 0 */
1488:
1489: /* Read a sequence of keys that ends with a non prefix character,
1490: and store them in KEYBUF, a buffer of size BUFSIZE.
1491: Prompt with PROMPT. Echo starting immediately unless `prompt' is 0.
1492: Return the length of the key sequence stored.
1493: NODISPLAY nonzero means don't do redisplay before the first character
1494: (just for speedup). */
1495:
1496: int
1497: read_key_sequence (keybuf, bufsize, prompt, nodisplay)
1498: char *keybuf;
1499: int bufsize;
1500: unsigned char *prompt;
1501: int nodisplay;
1502: {
1503: register int i;
1504: Lisp_Object nextlocal, nextglobal;
1505: register int c, nextc;
1506: Lisp_Object local, global;
1507:
1508: if (FROM_KBD)
1509: {
1510: if (prompt)
1511: echo_prompt (prompt);
1512: else if (cursor_in_echo_area)
1513: echo_dash ();
1514: }
1515:
1516: nextc = read_command_char (nodisplay ? -1 : !prompt);
1517: nextlocal = current_buffer->keymap;
1518: XSET (nextglobal, Lisp_Vector, global_map);
1519:
1520: i = 0;
1521: while (!NULL (nextlocal) || !NULL (nextglobal))
1522: {
1523: if (i == bufsize)
1524: error ("key sequence too long");
1525:
1526: if (nextc >= 0)
1527: {
1528: c = nextc;
1529: nextc = -1;
1530: }
1531: else
1532: c = read_command_char (!prompt);
1533: Vquit_flag = Qnil;
1534: nodisplay = 0;
1535:
1536: if (c < 0)
1537: return 0;
1538: if (c >= 0200)
1539: {
1540: nextc = c & 0177;
1541: c = meta_prefix_char;
1542: }
1543:
1544: keybuf[i] = c;
1545:
1546: global = !NULL (nextglobal)
1547: ? get_keyelt (access_keymap (nextglobal, c))
1548: : Qnil;
1549:
1550: local = !NULL (nextlocal)
1551: ? get_keyelt (access_keymap (nextlocal, c))
1552: : Qnil;
1553:
1554: /* If C is not defined in either keymap
1555: and it is an uppercase letter, try corresponding lowercase. */
1556:
1557: if (NULL (global) && NULL (local) && UPPERCASEP (c))
1558: {
1559: global = !NULL (nextglobal)
1560: ? get_keyelt (access_keymap (nextglobal, DOWNCASE (c)))
1561: : Qnil;
1562:
1563: local = !NULL (nextlocal)
1564: ? get_keyelt (access_keymap (nextlocal, DOWNCASE (c)))
1565: : Qnil;
1566:
1567: /* If that has worked better that the original char,
1568: downcase it permanently. */
1569:
1570: if (!NULL (global) || !NULL (local))
1571: {
1572: keybuf[i] = c = DOWNCASE (c);
1573: }
1574: }
1575:
1576: i++;
1577:
1578: nextlocal = Qnil;
1579: nextglobal = Qnil;
1580:
1581: read_key_sequence_cmd = !NULL (local) ? local : global;
1582:
1583: /* trace symbols to their function definitions */
1584:
1585: while (XTYPE (global) == Lisp_Symbol && !NULL (global)
1586: && !EQ (global, Qunbound))
1587: global = XSYMBOL (global)->function;
1588: while (XTYPE (local) == Lisp_Symbol && !NULL (local)
1589: && !EQ (local, Qunbound))
1590: local = XSYMBOL (local)->function;
1591:
1592: /* Are the definitions prefix characters? */
1593:
1594: if (XTYPE (local) == Lisp_Vector ||
1595: (CONSP (local) && EQ (XCONS (local)->car, Qkeymap))
1596: ||
1597: /* If nextc is set, we are processing a prefix char
1598: that represents a meta-bit.
1599: Let a global prefix definition override a local non-prefix.
1600: This is for minibuffers that redefine Escape for completion.
1601: A real Escape gets completion, but Meta bits get ESC-prefix. */
1602: ((NULL (local) || nextc >= 0)
1603: && (XTYPE (global) == Lisp_Vector ||
1604: (CONSP (global) && EQ (XCONS (global)->car, Qkeymap)))))
1605: {
1606: if (XTYPE (local) == Lisp_Vector ||
1607: (CONSP (local) && EQ (XCONS (local)->car, Qkeymap)))
1608: nextlocal = local;
1609: else
1610: nextlocal = Qnil;
1611:
1612: if (XTYPE (global) == Lisp_Vector ||
1613: (CONSP (global) && EQ (XCONS (global)->car, Qkeymap)))
1614: nextglobal = global;
1615: else
1616: nextglobal = Qnil;
1617: }
1618: }
1619:
1620: return i;
1621: }
1622:
1623: DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 1, 0,
1624: "Read a sequence of keystrokes and return as a string.\n\
1625: The sequence is sufficient to specify a non-prefix command\n\
1626: starting from the current local and global keymaps.\n\
1627: A C-g typed while in this function is treated like\n\
1628: any other character, and quit-flag is not set.\n\
1629: One arg, PROMPT, a prompt string or nil, meaning do not prompt specially.")
1630: (prompt)
1631: Lisp_Object prompt;
1632: {
1633: char keybuf[30];
1634: register int i;
1635:
1636: if (!NULL (prompt))
1637: CHECK_STRING (prompt, 0);
1638: QUIT;
1639:
1640: this_command_key_count = 0;
1641: i = read_key_sequence (keybuf, sizeof keybuf,
1642: (NULL (prompt)) ? 0 : XSTRING (prompt)->data,
1643: 0);
1644: return make_string (keybuf, i);
1645: }
1646:
1647: DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 2, 0,
1648: "Execute CMD as an editor command.\n\
1649: CMD must be a symbol that satisfies the `commandp' predicate.\n\
1650: Optional second arg RECORD-FLAG non-nil\n\
1651: means unconditionally put this command in the command-history.\n\
1652: Otherwise, this is done only if an arg is read using the minibuffer.")
1653: (cmd, record)
1654: Lisp_Object cmd, record;
1655: {
1656: register Lisp_Object final;
1657: register Lisp_Object tem;
1658: Lisp_Object prefixarg;
1659: struct backtrace backtrace;
1660: extern int debug_on_next_call;
1661:
1662: prefixarg = Vprefix_arg, Vprefix_arg = Qnil;
1663: Vcurrent_prefix_arg = prefixarg;
1664: debug_on_next_call = 0;
1665:
1666: if (XTYPE (cmd) == Lisp_Symbol)
1667: {
1668: tem = Fget (cmd, Qdisabled);
1669: if (!NULL (tem))
1670: return call0 (Vdisabled_command_hook);
1671: }
1672:
1673: while (1)
1674: {
1675: final = cmd;
1676: while (XTYPE (final) == Lisp_Symbol)
1677: {
1678: if (EQ (Qunbound, XSYMBOL (final)->function))
1679: Fsymbol_function (final); /* Get an error! */
1680: final = XSYMBOL (final)->function;
1681: }
1682:
1683: if (CONSP (final) && (tem = Fcar (final), EQ (tem, Qautoload)))
1684: do_autoload (final, cmd);
1685: else
1686: break;
1687: }
1688:
1689: if (CONSP (final) || XTYPE (final) == Lisp_Subr)
1690: {
1691: backtrace.next = backtrace_list;
1692: backtrace_list = &backtrace;
1693: backtrace.function = &Qcall_interactively;
1694: backtrace.args = &cmd;
1695: backtrace.nargs = 1;
1696: backtrace.evalargs = 0;
1697:
1698: tem = Fcall_interactively (cmd, record);
1699:
1700: backtrace_list = backtrace.next;
1701: return tem;
1702: }
1703: if (XTYPE (final) == Lisp_String)
1704: {
1705: return Fexecute_kbd_macro (final, prefixarg);
1706: }
1707: return Qnil;
1708: }
1709:
1710: DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
1711: 1, 1, "P",
1712: "Read function name, then read its arguments and call it.")
1713: (prefixarg)
1714: Lisp_Object prefixarg;
1715: {
1716: Lisp_Object function;
1717: char buf[40];
1718: Lisp_Object saved_keys;
1719: struct gcpro gcpro1;
1720:
1721: saved_keys = Fthis_command_keys ();
1722: GCPRO1 (saved_keys);
1723:
1724: buf[0] = 0;
1725:
1726: if (EQ (prefixarg, Qminus))
1727: strcpy (buf, "- ");
1728: else if (CONSP (prefixarg) && XINT (XCONS (prefixarg)->car) == 4)
1729: strcpy (buf, "C-u ");
1730: else if (CONSP (prefixarg) && XTYPE (XCONS (prefixarg)->car) == Lisp_Int)
1731: sprintf (buf, "%d ", XINT (XCONS (prefixarg)->car));
1732: else if (XTYPE (prefixarg) == Lisp_Int)
1733: sprintf (buf, "%d ", XINT (prefixarg));
1734:
1735: /* This isn't strictly correct if execute-extended-command
1736: is bound to anything else */
1737: strcat (buf, "M-x ");
1738:
1739: function = Fcompleting_read (build_string (buf), Vobarray, Qcommandp, Qt, Qnil);
1740:
1741: saved_keys = concat2 (saved_keys, function);
1742: if (this_command_keys_size < XSTRING (saved_keys)->size)
1743: {
1744: /* This makes the buffer bigger than necessary, but that's okay. */
1745: this_command_keys_size += XSTRING (saved_keys)->size;
1746: this_command_keys = (unsigned char *) xrealloc (this_command_keys,
1747: this_command_keys_size);
1748: }
1749: bcopy (XSTRING (saved_keys)->data, this_command_keys,
1750: XSTRING (saved_keys)->size + 1);
1751: this_command_key_count = XSTRING (saved_keys)->size;
1752:
1753: UNGCPRO;
1754:
1755: function = Fintern (function, Vobarray);
1756: Vprefix_arg = prefixarg;
1757: this_command = function;
1758:
1759: return Fcommand_execute (function, Qt);
1760: }
1761:
1762: detect_input_pending ()
1763: {
1764: if (!input_pending)
1765: get_input_pending (&input_pending);
1766:
1767: return input_pending;
1768: }
1769:
1770: /* This is called in some cases before a possible quit.
1771: It cases the next call to detect_input_pending to recompute input_pending.
1772: So calling this function unnecessarily can't do any harm. */
1773: clear_input_pending ()
1774: {
1775: input_pending = 0;
1776: }
1777:
1778: DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
1779: "T if command input is currently available with no waiting.\n\
1780: Actually, the value is NIL only if we can be sure that no input is available.")
1781: ()
1782: {
1783: if (unread_command_char >= 0) return Qt;
1784:
1785: return detect_input_pending () ? Qt : Qnil;
1786: }
1787:
1788: DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
1789: "Return string of last 100 chars read from terminal.")
1790: ()
1791: {
1792: Lisp_Object val;
1793: if (total_keys < sizeof recent_keys)
1794: return make_string (recent_keys, total_keys);
1795:
1796: val = make_string (recent_keys, sizeof recent_keys);
1797: bcopy (recent_keys + recent_keys_index,
1798: XSTRING (val)->data,
1799: sizeof recent_keys - recent_keys_index);
1800: bcopy (recent_keys,
1801: XSTRING (val)->data + sizeof recent_keys - recent_keys_index,
1802: recent_keys_index);
1803: return val;
1804: }
1805:
1806: DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
1807: "Return string of the keystrokes that invoked this command.")
1808: ()
1809: {
1810: return make_string (this_command_keys, this_command_key_count);
1811: }
1812:
1813: DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
1814: "Return the current depth in recursive edits.")
1815: ()
1816: {
1817: Lisp_Object temp;
1818: XFASTINT (temp) = command_loop_level + minibuf_level;
1819: return temp;
1820: }
1821:
1822: DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
1823: "FOpen dribble file: ",
1824: "Start writing all keyboard characters to FILE.\n\
1825: Use nil as an argument to close the dribble file.")
1826: (file)
1827: Lisp_Object file;
1828: {
1829: if (dribble != 0)
1830: fclose (dribble);
1831: dribble = 0;
1832: if (!NULL (file))
1833: {
1834: file = Fexpand_file_name (file, Qnil);
1835: dribble = fopen (XSTRING (file)->data, "w");
1836: }
1837: return Qnil;
1838: }
1839:
1840: DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
1841: "Discard the contents of the terminal input buffer.\n\
1842: Also flush any kbd macro definition in progress.")
1843: ()
1844: {
1845: defining_kbd_macro = 0;
1846: update_mode_lines++;
1847:
1848: unread_command_char = -1;
1849: Vquit_flag = Qnil;
1850: discard_tty_input ();
1851:
1852: kbd_count = 0;
1853: input_pending = 0;
1854:
1855: return Qnil;
1856: }
1857:
1858: DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
1859: "Stop Emacs and return to superior process. You can resume.\n\
1860: If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
1861: to be read as terminal input by Emacs's superior shell.\n\
1862: Before suspending, if `suspend-hook' is bound and value is non-nil\n\
1863: call the value as a function of no args. Don't suspend if it returns non-nil.\n\
1864: Otherwise, suspend normally and after resumption call\n\
1865: `suspend-resume-hook' if that is bound and non-nil.")
1866: (stuffstring)
1867: Lisp_Object stuffstring;
1868: {
1869: register Lisp_Object tem;
1870: int count = specpdl_ptr - specpdl;
1871: int old_height, old_width;
1872: int width, height;
1873: struct gcpro gcpro1;
1874: extern init_sys_modes ();
1875:
1876: if (!NULL (stuffstring))
1877: CHECK_STRING (stuffstring, 0);
1878: GCPRO1 (stuffstring);
1879:
1880: /* Call value of suspend-hook
1881: if it is bound and value is non-nil. */
1882: tem = intern ("suspend-hook");
1883: tem = XSYMBOL (tem)->value;
1884: if (! EQ (tem, Qunbound) && ! EQ (tem, Qnil))
1885: {
1886: tem = call0 (tem);
1887: if (!EQ (tem, Qnil)) return Qnil;
1888: }
1889:
1890: get_screen_size (&old_width, &old_height);
1891: reset_sys_modes ();
1892: /* sys_suspend can get an error if it tries to fork a subshell
1893: and the system resources aren't available for that. */
1894: record_unwind_protect (init_sys_modes, 0);
1895: stuff_buffered_input (stuffstring);
1896: sys_suspend ();
1897: unbind_to (count);
1898:
1899: /* Check if terminal/window size has changed.
1900: Note that this is not useful when we are running directly
1901: with a window system; but suspend should be disabled in that case. */
1902: get_screen_size (&width, &height);
1903: if (width != old_width || height != old_height)
1904: change_screen_size (height, width, 0, 0, 0);
1905:
1906: /* Call value of suspend-resume-hook
1907: if it is bound and value is non-nil. */
1908: tem = intern ("suspend-resume-hook");
1909: tem = XSYMBOL (tem)->value;
1910: if (! EQ (tem, Qunbound) && ! EQ (tem, Qnil))
1911: call0 (tem);
1912: UNGCPRO;
1913: return Qnil;
1914: }
1915:
1916: /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
1917: Then in any case stuff anthing Emacs has read ahead and not used. */
1918:
1919: stuff_buffered_input (stuffstring)
1920: Lisp_Object stuffstring;
1921: {
1922: register unsigned char *p;
1923:
1924: /* stuff_char works only in BSD, versions 4.2 and up. */
1925: #ifdef BSD
1926: #ifndef BSD4_1
1927: if (XTYPE (stuffstring) == Lisp_String)
1928: {
1929: register int count;
1930:
1931: p = XSTRING (stuffstring)->data;
1932: count = XSTRING (stuffstring)->size;
1933: while (count-- > 0)
1934: stuff_char (*p++);
1935: stuff_char ('\n');
1936: }
1937: /* Anything we have read ahead, put back for the shell to read. */
1938: while (kbd_count)
1939: {
1940: stuff_char (*kbd_ptr++);
1941: kbd_count--;
1942: }
1943: input_pending = 0;
1944: #endif
1945: #endif /* BSD and not BSD4_1 */
1946: }
1947:
1948: set_waiting_for_input (word_to_clear)
1949: long *word_to_clear;
1950: {
1951: input_available_clear_word = word_to_clear;
1952:
1953: /* Tell interrupt_signal to throw back to read_command_char, */
1954: waiting_for_input = 1;
1955:
1956: /* If interrupt_signal was called before and buffered a C-g,
1957: make it run again now, to avoid timing error. */
1958: if (!NULL (Vquit_flag))
1959: quit_throw_to_read_command_char ();
1960:
1961: /* Tell alarm signal to echo right away */
1962: echo_now = 1;
1963:
1964: /* If alarm has gone off already, echo now. */
1965: if (echo_flag)
1966: {
1967: echo ();
1968: echo_flag = 0;
1969: }
1970: }
1971:
1972: clear_waiting_for_input ()
1973: {
1974: /* Tell interrupt_signal not to throw back to read_command_char, */
1975: waiting_for_input = 0;
1976: echo_now = 0;
1977: input_available_clear_word = 0;
1978: }
1979:
1980: /* This routine is called at interrupt level in response to C-G.
1981: If interrupt_input, this is the handler for SIGINT.
1982: Otherwise, it is called from kbd_buffer_store_char,
1983: in handling SIGIO or SIGTINT.
1984:
1985: If `waiting_for_input' is non zero, then unless `echoing' is nonzero,
1986: immediately throw back to read_command_char.
1987:
1988: Otherwise it sets the Lisp variable quit-flag not-nil.
1989: This causes eval to throw, when it gets a chance.
1990: If quit-flag is already non-nil, it stops the job right away. */
1991:
1992: interrupt_signal ()
1993: {
1994: char c;
1995: /* Must preserve main program's value of errno. */
1996: int old_errno = errno;
1997: extern Lisp_Object Vwindow_system;
1998:
1999: #ifdef USG
2000: /* USG systems forget handlers when they are used;
2001: must reestablish each time */
2002: signal (SIGINT, interrupt_signal);
2003: signal (SIGQUIT, interrupt_signal);
2004: #endif /* USG */
2005:
2006: cancel_echoing ();
2007:
2008: if (!NULL (Vquit_flag) && NULL (Vwindow_system))
2009: {
2010: fflush (stdout);
2011: reset_sys_modes ();
2012: sigfree ();
2013: #ifdef SIGTSTP /* Support possible in later USG versions */
2014: /*
2015: * On systems which can suspend the current process and return to the original
2016: * shell, this command causes the user to end up back at the shell.
2017: * The "Auto-save" and "Abort" questions are not asked until
2018: * the user elects to return to emacs, at which point he can save the current
2019: * job and either dump core or continue.
2020: */
2021: sys_suspend ();
2022: #else
2023: #ifdef VMS
2024: if (sys_suspend () == -1)
2025: {
2026: printf ("Not running as a subprocess;\n");
2027: printf ("you can continue or abort.\n");
2028: }
2029: #else /* not VMS */
2030: /* Perhaps should really fork an inferior shell?
2031: But that would not provide any way to get back
2032: to the original shell, ever. */
2033: printf ("No support for stopping a process on this operating system;\n");
2034: printf ("you can continue or abort.\n");
2035: #endif /* not VMS */
2036: #endif /* not SIGTSTP */
2037: printf ("Auto-save? (y or n) ");
2038: fflush (stdout);
2039: if (((c = getchar ()) & ~040) == 'Y')
2040: Fdo_auto_save (Qnil);
2041: while (c != '\n') c = getchar ();
2042: #ifdef VMS
2043: printf ("Abort (and enter debugger)? (y or n) ");
2044: #else /* not VMS */
2045: printf ("Abort (and dump core)? (y or n) ");
2046: #endif /* not VMS */
2047: fflush (stdout);
2048: if (((c = getchar ()) & ~040) == 'Y')
2049: abort ();
2050: while (c != '\n') c = getchar ();
2051: printf ("Continuing...\n");
2052: fflush (stdout);
2053: init_sys_modes ();
2054: }
2055: else
2056: {
2057: /* If executing a function that wants to be interrupted out of
2058: and the user has not deferred quitting by binding `inhibit-quit'
2059: then quit right away. */
2060: if (immediate_quit && NULL (Vinhibit_quit))
2061: {
2062: immediate_quit = 0;
2063: sigfree ();
2064: Fsignal (Qquit, Qnil);
2065: }
2066: else
2067: /* Else request quit when it's safe */
2068: Vquit_flag = Qt;
2069: }
2070:
2071: if (waiting_for_input && !echoing)
2072: quit_throw_to_read_command_char ();
2073:
2074: errno = old_errno;
2075: }
2076:
2077: /* Handle a C-g by making read_command_char return C-g. */
2078:
2079: quit_throw_to_read_command_char ()
2080: {
2081: quit_error_check ();
2082: sigfree ();
2083: /* Prevent another signal from doing this before we finish. */
2084: waiting_for_input = 0;
2085: input_pending = 0;
2086: unread_command_char = -1;
2087: #ifdef POLL_FOR_INPUT
2088: if (poll_suppress_count != 1)
2089: abort ();
2090: #endif
2091: _longjmp (getcjmp, 1);
2092: }
2093:
2094: DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 2, 3, 0,
2095: "Set mode of reading keyboard input.\n\
2096: First arg non-nil means use input interrupts; nil means use CBREAK mode.\n\
2097: Second arg non-nil means use ^S/^Q flow control for output to terminal\n\
2098: (no effect except in CBREAK mode).\n\
2099: Optional third arg non-nil specifies character to use for quitting.\n\n\
2100: Note that the arguments will change incompatibly in version 19.")
2101: (interrupt, flow, quit)
2102: Lisp_Object interrupt, flow, quit;
2103: {
2104: reset_sys_modes ();
2105: #ifdef SIGIO
2106: /* Note SIGIO has been undef'd if FIONREAD is missing. */
2107: #ifdef NO_SOCK_SIGIO
2108: if (read_socket_hook)
2109: interrupt_input = 0; /* No interrupts if reading from a socket. */
2110: else
2111: #endif /* NO_SOCK_SIGIO */
2112: interrupt_input = !NULL (interrupt);
2113: #else /* not SIGIO */
2114: interrupt_input = 0;
2115: #endif /* not SIGIO */
2116: flow_control = !NULL (flow);
2117: if (!NULL (quit))
2118: {
2119: CHECK_NUMBER (quit, 2);
2120: quit_char = XINT (quit);
2121: /* Don't let this value be out of range. */
2122: quit_char &= (meta_key ? 0377 : 0177);
2123: }
2124: init_sys_modes ();
2125: return Qnil;
2126: }
2127:
2128: init_keyboard ()
2129: {
2130: this_command_keys_size = 40;
2131: this_command_keys = (unsigned char *) xmalloc (40);
2132:
2133: command_loop_level = -1; /* Correct, before outermost invocation. */
2134: quit_char = Ctl ('G');
2135: immediate_quit = 0;
2136: unread_command_char = -1;
2137: recent_keys_index = 0;
2138: total_keys = 0;
2139: kbd_count = 0;
2140: kbd_ptr = kbd_buffer;
2141: input_pending = 0;
2142: force_input = 0;
2143: if (!noninteractive)
2144: {
2145: signal (SIGINT, interrupt_signal);
2146: #ifdef HAVE_TERMIO
2147: /* On systems with TERMIO, C-g is set up for both SIGINT and SIGQUIT
2148: and we can't tell which one it will give us. */
2149: signal (SIGQUIT, interrupt_signal);
2150: #endif /* HAVE_TERMIO */
2151: /* Note SIGIO has been undef'd if FIONREAD is missing. */
2152: #ifdef SIGIO
2153: signal (SIGIO, input_available_signal);
2154: #endif /* SIGIO */
2155: }
2156:
2157: /* Use interrupt input by default, if it works and noninterrupt input
2158: has deficiencies. */
2159:
2160: #ifdef INTERRUPT_INPUT
2161: interrupt_input = 1;
2162: #else
2163: interrupt_input = 0;
2164: #endif
2165:
2166: sigfree ();
2167: dribble = 0;
2168:
2169: if (keyboard_init_hook)
2170: (*keyboard_init_hook) ();
2171:
2172: poll_suppress_count = 1;
2173: #ifdef POLL_FOR_INPUT
2174: start_polling ();
2175: #endif
2176: }
2177:
2178: syms_of_keyboard ()
2179: {
2180: Qself_insert_command = intern ("self-insert-command");
2181: staticpro (&Qself_insert_command);
2182:
2183: Qforward_char = intern ("forward-char");
2184: staticpro (&Qforward_char);
2185:
2186: Qbackward_char = intern ("backward-char");
2187: staticpro (&Qbackward_char);
2188:
2189: Qdisabled = intern ("disabled");
2190: staticpro (&Qdisabled);
2191:
2192: defsubr (&Sread_key_sequence);
2193: defsubr (&Srecursive_edit);
2194: defsubr (&Sinput_pending_p);
2195: defsubr (&Scommand_execute);
2196: defsubr (&Srecent_keys);
2197: defsubr (&Sthis_command_keys);
2198: defsubr (&Ssuspend_emacs);
2199: defsubr (&Sabort_recursive_edit);
2200: defsubr (&Sexit_recursive_edit);
2201: defsubr (&Srecursion_depth);
2202: defsubr (&Stop_level);
2203: defsubr (&Sdiscard_input);
2204: defsubr (&Sopen_dribble_file);
2205: defsubr (&Sset_input_mode);
2206: defsubr (&Sexecute_extended_command);
2207:
2208: DEFVAR_LISP ("disabled-command-hook", &Vdisabled_command_hook,
2209: "Value is called instead of any command that is disabled\n\
2210: \(has a non-nil disabled property).");
2211:
2212: DEFVAR_BOOL ("meta-flag", &meta_key,
2213: "*Non-nil means treat 0200 bit in terminal input as Meta bit.");
2214:
2215: DEFVAR_INT ("last-command-char", &last_command_char,
2216: "Last terminal input character that was part of a command, as an integer.");
2217:
2218: DEFVAR_INT ("last-input-char", &last_input_char,
2219: "Last terminal input character, as an integer.");
2220:
2221: DEFVAR_INT ("unread-command-char", &unread_command_char,
2222: "Character to be read as next input from command input stream, or -1 if none.");
2223:
2224: DEFVAR_INT ("meta-prefix-char", &meta_prefix_char,
2225: "Meta-prefix character code. Meta-foo as command input\n\
2226: turns into this character followed by foo.");
2227: meta_prefix_char = 033;
2228:
2229: DEFVAR_LISP ("last-command", &last_command,
2230: "The last command executed. Normally a symbol with a function definition,\n\
2231: but can be whatever was found in the keymap, or whatever the variable\n\
2232: `this-command' was set to by that command.");
2233: last_command = Qnil;
2234:
2235: DEFVAR_LISP ("this-command", &this_command,
2236: "The command now being executed.\n\
2237: The command can set this variable; whatever is put here\n\
2238: will be in last-command during the following command.");
2239: this_command = Qnil;
2240:
2241: DEFVAR_INT ("auto-save-interval", &auto_save_interval,
2242: "*Number of keyboard input characters between auto-saves.\n\
2243: Zero means disable autosaving.");
2244: auto_save_interval = 300;
2245:
2246: DEFVAR_INT ("echo-keystrokes", &echo_keystrokes,
2247: "*Nonzero means echo unfinished commands after this many seconds of pause.");
2248: echo_keystrokes = 1;
2249:
2250: DEFVAR_INT ("polling-period", &polling_period,
2251: "*Interval between polling for input during Lisp execution.\n\
2252: The reason for polling is to make C-g work to stop a running program.\n\
2253: Polling is needed only when using X windows and SIGIO does not work.\n\
2254: Polling is automatically disabled in all other cases.");
2255: polling_period = 2;
2256:
2257: DEFVAR_INT ("help-char", &help_char,
2258: "Character to recognize as meaning Help.\n\
2259: When it is read, do (eval help-form), and display result if it's a string.\n\
2260: If help-form's value is nil, this char can be read normally.");
2261: help_char = Ctl ('H');
2262:
2263: DEFVAR_LISP ("help-form", &Vhelp_form,
2264: "Form to execute when character help-char is read.\n\
2265: If the form returns a string, that string is displayed.\n\
2266: If help-form is nil, the help char is not recognized.");
2267: Vhelp_form = Qnil;
2268:
2269: DEFVAR_LISP ("top-level", &Vtop_level,
2270: "Form to evaluate when Emacs starts up.\n\
2271: Useful to set before you dump a modified Emacs.");
2272: Vtop_level = Qnil;
2273:
2274: DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table,
2275: "String used as translate table for keyboard input, or nil.\n\
2276: Each character is looked up in this string and the contents used instead.\n\
2277: If string is of length N, character codes N and up are untranslated.");
2278: Vkeyboard_translate_table = Qnil;
2279: }
2280:
2281: keys_of_keyboard ()
2282: {
2283: ndefkey (Vglobal_map, Ctl ('Z'), "suspend-emacs");
2284: ndefkey (Vctl_x_map, Ctl ('Z'), "suspend-emacs");
2285: ndefkey (Vesc_map, Ctl ('C'), "exit-recursive-edit");
2286: ndefkey (Vglobal_map, Ctl (']'), "abort-recursive-edit");
2287: ndefkey (Vesc_map, 'x', "execute-extended-command");
2288: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.