2 Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
3 Copyright (C) 1996 Ben Wing.
5 This file is part of SXEmacs
7 SXEmacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 SXEmacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Synched up with: Not in FSF. */
23 /* Written by Ben Wing. */
29 #include "TTY/console-tty.h" /* for Fconsole_tty_controlling process ins
30 suspend-console. Needs refactoring...*/
31 #include "events/events.h"
33 #include "redisplay.h"
37 Lisp_Object Vconsole_list, Vselected_console;
39 Lisp_Object Vcreate_console_hook, Vdelete_console_hook;
41 Lisp_Object Qconsolep, Qconsole_live_p;
42 Lisp_Object Qcreate_console_hook;
43 Lisp_Object Qdelete_console_hook;
45 Lisp_Object Qsuspend_hook;
46 Lisp_Object Qsuspend_resume_hook;
48 /* This structure holds the default values of the console-local
49 variables defined with DEFVAR_CONSOLE_LOCAL, that have special
50 slots in each console. The default value occupies the same slot
51 in this structure as an individual console's value occupies in
52 that console. Setting the default value also goes through the
53 list of consoles and stores into each console that does not say
54 it has a local value. */
55 Lisp_Object Vconsole_defaults;
56 static void *console_defaults_saved_slots;
58 /* This structure marks which slots in a console have corresponding
59 default values in console_defaults.
60 Each such slot has a nonzero value in this structure.
61 The value has only one nonzero bit.
63 When a console has its own local value for a slot,
64 the bit for that slot (found in the same slot in this structure)
65 is turned on in the console's local_var_flags slot.
67 If a slot in this structure is 0, then there is a DEFVAR_CONSOLE_LOCAL
68 for the slot, but there is no default value for it; the corresponding
69 slot in console_defaults is not used except to initialize newly-created
72 If a slot is -1, then there is a DEFVAR_CONSOLE_LOCAL for it
73 as well as a default value which is used to initialize newly-created
74 consoles and as a reset-value when local-vars are killed.
76 If a slot is -2, there is no DEFVAR_CONSOLE_LOCAL for it.
77 (The slot is always local, but there's no lisp variable for it.)
78 The default value is only used to initialize newly-creation consoles.
80 If a slot is -3, then there is no DEFVAR_CONSOLE_LOCAL for it but
81 there is a default which is used to initialize newly-creation
82 consoles and as a reset-value when local-vars are killed.
85 struct console console_local_flags;
87 /* This structure holds the names of symbols whose values may be
88 console-local. It is indexed and accessed in the same way as the above. */
89 static Lisp_Object Vconsole_local_symbols;
90 static void *console_local_symbols_saved_slots;
92 DEFINE_CONSOLE_TYPE(dead);
94 Lisp_Object Vconsole_type_list;
96 console_type_entry_dynarr *the_console_type_entry_dynarr;
98 static Lisp_Object mark_console(Lisp_Object obj)
100 struct console *con = XCONSOLE(obj);
102 #define MARKED_SLOT(x) mark_object (con->x)
103 #include "conslots.h"
106 /* Can be zero for Vconsole_defaults, Vconsole_local_symbols */
108 mark_object(con->conmeths->symbol);
109 MAYBE_CONMETH(con, mark_console, (con));
116 print_console(Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
118 struct console *con = XCONSOLE(obj);
121 error("printing unreadable object #<console %s 0x%x>",
122 XSTRING_DATA(con->name), con->header.uid);
124 write_fmt_string(printcharfun, "#<%s-console",
125 (!CONSOLE_LIVE_P(con) ? "dead" : CONSOLE_TYPE_NAME(con)));
126 if (CONSOLE_LIVE_P(con) && !NILP(CONSOLE_CONNECTION(con))) {
127 write_c_string(" on ", printcharfun);
128 print_internal(CONSOLE_CONNECTION(con), printcharfun, 1);
130 write_fmt_str(printcharfun, " 0x%x>", con->header.uid);
133 DEFINE_LRECORD_IMPLEMENTATION("console", console,
134 mark_console, print_console, 0, 0, 0, 0,
137 static struct console *allocate_console(void)
140 struct console *con =
141 alloc_lcrecord_type(struct console, &lrecord_console);
144 copy_lcrecord(con, XCONSOLE(Vconsole_defaults));
146 XSETCONSOLE(console, con);
149 con->quit_char = 7; /* C-g */
150 con->command_builder = allocate_command_builder(console);
151 con->function_key_map = Fmake_sparse_keymap(Qnil);
157 struct console *decode_console(Lisp_Object console)
160 console = Fselected_console();
161 /* quietly accept devices and frames for the console arg */
162 if (DEVICEP(console) || FRAMEP(console))
163 console = DEVICE_CONSOLE(decode_device(console));
164 CHECK_LIVE_CONSOLE(console);
165 return XCONSOLE(console);
168 struct console_methods *decode_console_type(Lisp_Object type,
173 for (i = 0; i < Dynarr_length(the_console_type_entry_dynarr); i++)
175 (type, Dynarr_at(the_console_type_entry_dynarr, i).symbol))
176 return Dynarr_at(the_console_type_entry_dynarr,
179 maybe_signal_simple_error("Invalid console type", type, Qconsole, errb);
184 int valid_console_type_p(Lisp_Object type)
186 return decode_console_type(type, ERROR_ME_NOT) != 0;
189 DEFUN("valid-console-type-p", Fvalid_console_type_p, 1, 1, 0, /*
190 Return t if CONSOLE-TYPE is a valid console type.
191 Valid types are 'x, 'tty, and 'stream.
195 return valid_console_type_p(console_type) ? Qt : Qnil;
198 DEFUN("console-type-list", Fconsole_type_list, 0, 0, 0, /*
199 Return a list of valid console types.
203 return Fcopy_sequence(Vconsole_type_list);
206 DEFUN("cdfw-console", Fcdfw_console, 1, 1, 0, /*
207 Given a console, device, frame, or window, return the associated console.
208 Return nil otherwise.
212 return CDFW_CONSOLE(object);
215 DEFUN("selected-console", Fselected_console, 0, 0, 0, /*
216 Return the console which is currently active.
220 return Vselected_console;
223 /* Called from selected_device_1(), called from selected_frame_1(),
224 called from Fselect_window() */
225 void select_console_1(Lisp_Object console)
227 /* perhaps this should do something more complicated */
228 Vselected_console = console;
230 /* #### Schedule this to be removed in 19.14 */
231 #ifdef HAVE_X_WINDOWS
232 if (CONSOLE_X_P(XCONSOLE(console)))
236 Vwindow_system = Qnil;
239 DEFUN("select-console", Fselect_console, 1, 1, 0, /*
240 Select the console CONSOLE.
241 Subsequent editing commands apply to its selected device, selected frame,
242 and selected window. The selection of CONSOLE lasts until the next time
243 the user does something to select a different console, or until the next
244 time this function is called.
250 CHECK_LIVE_CONSOLE(console);
252 device = CONSOLE_SELECTED_DEVICE(XCONSOLE(console));
254 struct device *d = XDEVICE(device);
255 Lisp_Object frame = DEVICE_SELECTED_FRAME(d);
257 struct frame *f = XFRAME(frame);
258 Fselect_window(FRAME_SELECTED_WINDOW(f), Qnil);
260 error("Can't select console with no frames.");
262 error("Can't select a console with no devices");
266 void set_console_last_nonminibuf_frame(struct console *con, Lisp_Object frame)
268 con->last_nonminibuf_frame = frame;
271 DEFUN("consolep", Fconsolep, 1, 1, 0, /*
272 Return non-nil if OBJECT is a console.
276 return CONSOLEP(object) ? Qt : Qnil;
279 DEFUN("console-live-p", Fconsole_live_p, 1, 1, 0, /*
280 Return non-nil if OBJECT is a console that has not been deleted.
284 return CONSOLEP(object) && CONSOLE_LIVE_P(XCONSOLE(object)) ? Qt : Qnil;
287 DEFUN("console-type", Fconsole_type, 0, 1, 0, /*
288 Return the console type (e.g. `x' or `tty') of CONSOLE.
289 Value is `tty' for a tty console (a character-only terminal),
290 `x' for a console that is an X display,
291 `mswindows' for a console that is a Windows NT/95/97 connection,
292 `pc' for a console that is a direct-write MS-DOS connection (not yet
294 `stream' for a stream console (which acts like a stdio stream), and
295 `dead' for a deleted console.
299 /* don't call decode_console() because we want to allow for dead
302 console = Fselected_console();
303 CHECK_CONSOLE(console);
304 return CONSOLE_TYPE(XCONSOLE(console));
307 DEFUN("console-name", Fconsole_name, 0, 1, 0, /*
308 Return the name of CONSOLE.
312 return CONSOLE_NAME(decode_console(console));
315 DEFUN("console-connection", Fconsole_connection, 0, 1, 0, /*
316 Return the connection of the specified console.
317 CONSOLE defaults to the selected console if omitted.
321 return CONSOLE_CONNECTION(decode_console(console));
324 Lisp_Object make_console(struct console * con)
327 XSETCONSOLE(console, con);
332 semi_canonicalize_console_connection(struct console_methods *meths,
333 Lisp_Object name, Error_behavior errb)
335 if (HAS_CONTYPE_METH_P(meths, semi_canonicalize_console_connection))
336 return CONTYPE_METH(meths, semi_canonicalize_console_connection,
339 return CONTYPE_METH_OR_GIVEN(meths,
340 canonicalize_console_connection,
345 canonicalize_console_connection(struct console_methods *meths,
346 Lisp_Object name, Error_behavior errb)
348 if (HAS_CONTYPE_METH_P(meths, canonicalize_console_connection))
349 return CONTYPE_METH(meths, canonicalize_console_connection,
352 return CONTYPE_METH_OR_GIVEN(meths,
353 semi_canonicalize_console_connection,
358 find_console_of_type(struct console_methods *meths, Lisp_Object canon)
362 CONSOLE_LOOP(concons) {
363 Lisp_Object console = XCAR(concons);
365 if (EQ(CONMETH_TYPE(meths), CONSOLE_TYPE(XCONSOLE(console)))
367 internal_equal(CONSOLE_CANON_CONNECTION(XCONSOLE(console)),
375 DEFUN("find-console", Ffind_console, 1, 2, 0, /*
376 Look for an existing console attached to connection CONNECTION.
377 Return the console if found; otherwise, return nil.
379 If TYPE is specified, only return consoles of that type; otherwise,
380 return consoles of any type. (It is possible, although unlikely,
381 that two consoles of different types could have the same connection
382 name; in such a case, the first console found is returned.)
386 Lisp_Object canon = Qnil;
392 struct console_methods *conmeths =
393 decode_console_type(type, ERROR_ME);
395 canonicalize_console_connection(conmeths, connection,
398 RETURN_UNGCPRO(Qnil);
400 RETURN_UNGCPRO(find_console_of_type(conmeths, canon));
404 for (i = 0; i < Dynarr_length(the_console_type_entry_dynarr);
406 struct console_methods *conmeths =
407 Dynarr_at(the_console_type_entry_dynarr, i).meths;
409 canonicalize_console_connection(conmeths,
412 if (!UNBOUNDP(canon)) {
413 Lisp_Object console =
414 find_console_of_type(conmeths, canon);
416 RETURN_UNGCPRO(console);
420 RETURN_UNGCPRO(Qnil);
424 DEFUN("get-console", Fget_console, 1, 2, 0, /*
425 Look for an existing console attached to connection CONNECTION.
426 Return the console if found; otherwise, signal an error.
428 If TYPE is specified, only return consoles of that type; otherwise,
429 return consoles of any type. (It is possible, although unlikely,
430 that two consoles of different types could have the same connection
431 name; in such a case, the first console found is returned.)
435 Lisp_Object console = Ffind_console(connection, type);
438 signal_simple_error("No such console", connection);
440 signal_simple_error_2("No such console", type,
447 create_console(Lisp_Object name, Lisp_Object type, Lisp_Object connection,
450 /* This function can GC */
455 console = Ffind_console(connection, type);
459 con = allocate_console();
460 XSETCONSOLE(console, con);
464 con->conmeths = decode_console_type(type, ERROR_ME);
466 CONSOLE_NAME(con) = name;
467 CONSOLE_CONNECTION(con) =
468 semi_canonicalize_console_connection(con->conmeths, connection,
470 CONSOLE_CANON_CONNECTION(con) =
471 canonicalize_console_connection(con->conmeths, connection,
474 MAYBE_CONMETH(con, init_console, (con, props));
476 /* Do it this way so that the console list is in order of creation */
477 Vconsole_list = nconc2(Vconsole_list, Fcons(console, Qnil));
479 if (CONMETH_OR_GIVEN(con, initially_selected_for_input, (con), 0))
480 event_stream_select_console(con);
487 add_entry_to_console_type_list(Lisp_Object symbol,
488 struct console_methods *meths)
490 struct console_type_entry entry;
492 entry.symbol = symbol;
494 Dynarr_add(the_console_type_entry_dynarr, entry);
495 Vconsole_type_list = Fcons(symbol, Vconsole_type_list);
498 /* find a console other than the selected one. Prefer non-stream
499 consoles over stream consoles. */
501 static Lisp_Object find_other_console(Lisp_Object console)
505 /* look for a non-stream console */
506 CONSOLE_LOOP(concons) {
507 Lisp_Object con = XCAR(concons);
508 if (!CONSOLE_STREAM_P(XCONSOLE(con))
510 && !NILP(CONSOLE_SELECTED_DEVICE(XCONSOLE(con)))
511 && !NILP(DEVICE_SELECTED_FRAME
512 (XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(con))))))
516 return XCAR(concons);
518 /* OK, now look for a stream console */
519 CONSOLE_LOOP(concons) {
520 Lisp_Object con = XCAR(concons);
521 if (!EQ(con, console)
522 && !NILP(CONSOLE_SELECTED_DEVICE(XCONSOLE(con)))
523 && !NILP(DEVICE_SELECTED_FRAME
524 (XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(con))))))
528 return XCAR(concons);
530 /* Sorry, there ain't none */
535 find_nonminibuffer_frame_not_on_console_predicate(Lisp_Object frame,
540 VOID_TO_LISP(console, closure);
541 if (FRAME_MINIBUF_ONLY_P(XFRAME(frame)))
543 if (EQ(console, FRAME_CONSOLE(XFRAME(frame))))
548 static Lisp_Object find_nonminibuffer_frame_not_on_console(Lisp_Object console)
551 find_some_frame(find_nonminibuffer_frame_not_on_console_predicate,
552 LISP_TO_VOID(console));
555 /* Delete console CON.
557 If FORCE is non-zero, allow deletion of the only frame.
559 If CALLED_FROM_KILL_EMACS is non-zero, then, if
560 deleting the last console, just delete it,
561 instead of calling `save-buffers-kill-emacs'.
563 If FROM_IO_ERROR is non-zero, then the console is gone due
564 to an I/O error. This affects what happens if we exit
565 (we do an emergency exit instead of `save-buffers-kill-emacs'.)
569 delete_console_internal(struct console *con, int force,
570 int called_from_kill_emacs, int from_io_error)
572 /* This function can GC */
576 /* OK to delete an already-deleted console. */
577 if (!CONSOLE_LIVE_P(con))
580 XSETCONSOLE(console, con);
583 if (!called_from_kill_emacs) {
586 if ((XINT(Flength(Vconsole_list)) == 1)
587 /* if we just created the console, it might not be listed,
589 && !NILP(memq_no_quit(console, Vconsole_list)))
591 /* If there aren't any nonminibuffer frames that would
592 be left, then exit. */
593 else if (NILP(find_nonminibuffer_frame_not_on_console(console)))
598 error("Attempt to delete the only frame");
599 else if (from_io_error) {
600 /* Mayday mayday! We're going down! */
601 stderr_out(" Autosaving and exiting...\n");
602 Vwindow_system = Qnil; /* let it lie! */
603 preparing_for_armageddon = 1;
604 Fkill_emacs(make_int(70));
606 call0(Qsave_buffers_kill_emacs);
608 /* If we get here, the user said they didn't want
609 to exit, so don't. */
615 /* Breathe a sigh of relief. We're still alive. */
618 Lisp_Object frmcons, devcons;
620 /* First delete all frames without their own minibuffers,
621 to avoid errors coming from attempting to delete a frame
622 that is a surrogate for another frame.
624 We don't set "called_from_delete_console" because we want the
625 device to go ahead and get deleted if we delete the last frame
626 on a device. We won't run into trouble here because for any
627 frame without a minibuffer, there has to be another one on
628 the same console with a minibuffer, and we're not deleting that,
629 so delete_console_internal() won't get recursively called.
631 WRONG! With surrogate minibuffers this isn't true. Frames
632 with only a minibuffer are not enough to prevent
633 delete_frame_internal from triggering a device deletion. */
634 CONSOLE_FRAME_LOOP_NO_BREAK(frmcons, devcons, con) {
635 struct frame *f = XFRAME(XCAR(frmcons));
636 /* delete_frame_internal() might do anything such as run hooks,
638 if (FRAME_LIVE_P(f) && !FRAME_HAS_MINIBUF_P(f))
639 delete_frame_internal(f, 1, 1, from_io_error);
641 if (!CONSOLE_LIVE_P(con)) { /* make sure the delete-*-hook didn't
642 go ahead and delete anything */
648 CONSOLE_DEVICE_LOOP(devcons, con) {
649 struct device *d = XDEVICE(XCAR(devcons));
650 /* delete_device_internal() might do anything such as run hooks,
652 if (DEVICE_LIVE_P(d))
653 delete_device_internal(d, 1, 1, from_io_error);
654 if (!CONSOLE_LIVE_P(con)) { /* make sure the delete-*-hook didn't
655 go ahead and delete anything */
662 CONSOLE_SELECTED_DEVICE(con) = Qnil;
664 /* try to select another console */
666 if (EQ(console, Fselected_console())) {
667 Lisp_Object other_dev = find_other_console(console);
668 if (!NILP(other_dev))
669 Fselect_console(other_dev);
672 Vselected_console = Qnil;
673 Vwindow_system = Qnil;
677 if (con->input_enabled)
678 event_stream_unselect_console(con);
680 MAYBE_CONMETH(con, delete_console, (con));
682 Vconsole_list = delq_no_quit(console, Vconsole_list);
683 RESET_CHANGED_SET_FLAGS;
684 con->conmeths = dead_console_methods;
689 void io_error_delete_console(Lisp_Object console)
691 delete_console_internal(XCONSOLE(console), 1, 0, 1);
694 DEFUN("delete-console", Fdelete_console, 1, 2, 0, /*
695 Delete CONSOLE, permanently eliminating it from use.
696 Normally, you cannot delete the last non-minibuffer-only frame (you must
697 use `save-buffers-kill-emacs' or `kill-emacs'). However, if optional
698 second argument FORCE is non-nil, you can delete the last frame. (This
699 will automatically call `save-buffers-kill-emacs'.)
703 CHECK_CONSOLE(console);
704 delete_console_internal(XCONSOLE(console), !NILP(force), 0, 0);
708 DEFUN("console-list", Fconsole_list, 0, 0, 0, /*
709 Return a list of all consoles.
713 return Fcopy_sequence(Vconsole_list);
716 DEFUN("console-device-list", Fconsole_device_list, 0, 1, 0, /*
717 Return a list of all devices on CONSOLE.
718 If CONSOLE is nil, the selected console is used.
722 return Fcopy_sequence(CONSOLE_DEVICE_LIST(decode_console(console)));
725 DEFUN("console-enable-input", Fconsole_enable_input, 1, 1, 0, /*
726 Enable input on console CONSOLE.
730 struct console *con = decode_console(console);
731 if (!con->input_enabled)
732 event_stream_select_console(con);
736 DEFUN("console-disable-input", Fconsole_disable_input, 1, 1, 0, /*
737 Disable input on console CONSOLE.
741 struct console *con = decode_console(console);
742 if (con->input_enabled)
743 event_stream_unselect_console(con);
747 DEFUN("console-on-window-system-p", Fconsole_on_window_system_p, 0, 1, 0, /*
748 Return t if CONSOLE is on a window system.
749 If CONSOLE is nil, the selected console is used.
750 This generally means that there is support for the mouse, the menubar,
751 the toolbar, glyphs, etc.
755 Lisp_Object type = CONSOLE_TYPE(decode_console(console));
757 return !EQ(type, Qtty) && !EQ(type, Qstream) ? Qt : Qnil;
760 /**********************************************************************/
761 /* Miscellaneous low-level functions */
762 /**********************************************************************/
764 static Lisp_Object unwind_init_sys_modes(Lisp_Object console)
766 reinit_initial_console();
768 if (!no_redraw_on_reenter &&
769 CONSOLEP(console) && CONSOLE_LIVE_P(XCONSOLE(console))) {
771 XFRAME(DEVICE_SELECTED_FRAME
773 (CONSOLE_SELECTED_DEVICE(XCONSOLE(console)))));
774 MARK_FRAME_CHANGED(f);
779 DEFUN("suspend-emacs", Fsuspend_emacs, 0, 1, "", /*
780 Stop Emacs and return to superior process. You can resume later.
781 On systems that don't have job control, run a subshell instead.
783 If optional arg STUFFSTRING is non-nil, its characters are stuffed
784 to be read as terminal input by Emacs's superior shell.
786 Before suspending, run the normal hook `suspend-hook'.
787 After resumption run the normal hook `suspend-resume-hook'.
789 Some operating systems cannot stop the Emacs process and resume it later.
790 On such systems, Emacs will start a subshell and wait for it to exit.
794 int speccount = specpdl_depth();
797 if (!NILP(stuffstring))
798 CHECK_STRING(stuffstring);
801 /* There used to be a check that the initial console is TTY.
802 This is bogus. Even checking to see whether any console
803 is a controlling terminal is not correct -- maybe
804 the user used the -t option or something. If we want to
805 suspend, then we suspend. Period. */
807 /* Call value of suspend-hook. */
808 run_hook(Qsuspend_hook);
810 reset_initial_console();
811 /* sys_suspend can get an error if it tries to fork a subshell
812 and the system resources aren't available for that. */
813 record_unwind_protect(unwind_init_sys_modes, Vcontrolling_terminal);
814 stuff_buffered_input(stuffstring);
816 /* the console is un-reset inside of the unwind-protect. */
817 unbind_to(speccount, Qnil);
820 /* It is possible that a size change occurred while we were
821 suspended. Assume one did just to be safe. It won't hurt
822 anything if one didn't. */
823 asynch_device_change_pending++;
826 /* Call value of suspend-resume-hook
827 if it is bound and value is non-nil. */
828 run_hook(Qsuspend_resume_hook);
834 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
835 Then in any case stuff anything Emacs has read ahead and not used. */
837 void stuff_buffered_input(Lisp_Object stuffstring)
839 /* stuff_char works only in BSD, versions 4.2 and up. */
840 #if defined (BSD) && defined (HAVE_TTY)
841 if (!CONSOLEP(Vcontrolling_terminal) ||
842 !CONSOLE_LIVE_P(XCONSOLE(Vcontrolling_terminal)))
845 if (STRINGP(stuffstring)) {
849 TO_EXTERNAL_FORMAT(LISP_STRING, stuffstring,
850 ALLOCA, (p, count), Qkeyboard);
852 stuff_char(XCONSOLE(Vcontrolling_terminal), *p++);
853 stuff_char(XCONSOLE(Vcontrolling_terminal), '\n');
855 /* Anything we have read ahead, put back for the shell to read. */
856 # if 0 /* oh, who cares about this silliness */
857 while (kbd_fetch_ptr != kbd_store_ptr) {
858 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
859 kbd_fetch_ptr = kbd_buffer;
860 stuff_char(XCONSOLE(Vcontrolling_terminal), *kbd_fetch_ptr++);
863 #endif /* BSD && HAVE_TTY */
866 DEFUN("suspend-console", Fsuspend_console, 0, 1, "", /*
867 Suspend a console. For tty consoles, it sends a signal to suspend
868 the process in charge of the tty, and removes the devices and
869 frames of that console from the display.
871 If optional arg CONSOLE is non-nil, it is the console to be suspended.
872 Otherwise it is assumed to be the selected console.
874 Some operating systems cannot stop processes and resume them later.
875 On such systems, who knows what will happen.
880 struct console *con = decode_console(console);
882 if (CONSOLE_TTY_P(con)) {
884 * hide all the unhidden frames so the display code won't update
885 * them while the console is suspended.
887 Lisp_Object device = CONSOLE_SELECTED_DEVICE(con);
889 struct device *d = XDEVICE(device);
890 Lisp_Object frame_list = DEVICE_FRAME_LIST(d);
891 while (CONSP(frame_list)) {
892 struct frame *f = XFRAME(XCAR(frame_list));
893 if (FRAME_REPAINT_P(f))
895 frame_list = XCDR(frame_list);
898 reset_one_console(con);
899 event_stream_unselect_console(con);
900 sys_suspend_process(XINT
901 (Fconsole_tty_controlling_process
904 #endif /* HAVE_TTY */
909 DEFUN("resume-console", Fresume_console, 1, 1, "", /*
910 Re-initialize a previously suspended console.
911 For tty consoles, do stuff to the tty to make it sane again.
916 struct console *con = decode_console(console);
918 if (CONSOLE_TTY_P(con)) {
919 /* raise the selected frame */
920 Lisp_Object device = CONSOLE_SELECTED_DEVICE(con);
922 struct device *d = XDEVICE(device);
923 Lisp_Object frame = DEVICE_SELECTED_FRAME(d);
925 /* force the frame to be cleared */
926 SET_FRAME_CLEAR(XFRAME(frame));
930 init_one_console(con);
931 event_stream_select_console(con);
933 /* The same as in Fsuspend_emacs: it is possible that a size
934 change occurred while we were suspended. Assume one did just
935 to be safe. It won't hurt anything if one didn't. */
936 asynch_device_change_pending++;
939 #endif /* HAVE_TTY */
944 DEFUN("set-input-mode", Fset_input_mode, 3, 5, 0, /*
945 Set mode of reading keyboard input.
946 First arg is ignored, for backward compatibility.
947 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
948 (no effect except in CBREAK mode).
949 Third arg META t means accept 8-bit input (for a Meta key).
950 META nil means ignore the top bit, on the assumption it is parity.
951 Otherwise, accept 8-bit input and don't use the top bit for Meta.
952 First three arguments only apply to TTY consoles.
953 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
954 Optional fifth arg CONSOLE specifies console to make changes to; nil means
955 the selected console.
956 See also `current-input-mode'.
958 (ignored, flow, meta, quit, console))
960 struct console *con = decode_console(console);
961 int meta_key = (!CONSOLE_TTY_P(con) ? 1 :
962 EQ(meta, Qnil) ? 0 : EQ(meta, Qt) ? 1 : 2);
965 CHECK_CHAR_COERCE_INT(quit);
966 CONSOLE_QUIT_CHAR(con) =
967 ((unsigned int)XCHAR(quit)) & (meta_key ? 0377 : 0177);
970 if (CONSOLE_TTY_P(con)) {
971 reset_one_console(con);
972 TTY_FLAGS(con).flow_control = !NILP(flow);
973 TTY_FLAGS(con).meta_key = meta_key;
974 init_one_console(con);
975 MARK_FRAME_CHANGED(XFRAME(CONSOLE_SELECTED_FRAME(con)));
982 DEFUN("current-input-mode", Fcurrent_input_mode, 0, 1, 0, /*
983 Return information about the way Emacs currently reads keyboard input.
984 Optional arg CONSOLE specifies console to return information about; nil means
985 the selected console.
986 The value is a list of the form (nil FLOW META QUIT), where
987 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
988 terminal; this does not apply if Emacs uses interrupt-driven input.
989 META is t if accepting 8-bit input with 8th bit as Meta flag.
990 META nil means ignoring the top bit, on the assumption it is parity.
991 META is neither t nor nil if accepting 8-bit input and using
992 all 8 bits as the character code.
993 QUIT is the character Emacs currently uses to quit.
994 FLOW, and META are only meaningful for TTY consoles.
995 The elements of this list correspond to the arguments of
1000 struct console *con = decode_console(console);
1001 Lisp_Object flow, meta, quit;
1004 flow = CONSOLE_TTY_P(con) && TTY_FLAGS(con).flow_control ? Qt : Qnil;
1005 meta = (!CONSOLE_TTY_P(con) ? Qt :
1006 TTY_FLAGS(con).meta_key == 1 ? Qt :
1007 TTY_FLAGS(con).meta_key == 2 ? Qzero : Qnil);
1012 quit = make_char(CONSOLE_QUIT_CHAR(con));
1014 return list4(Qnil, flow, meta, quit);
1017 /************************************************************************/
1018 /* initialization */
1019 /************************************************************************/
1021 void syms_of_console(void)
1023 INIT_LRECORD_IMPLEMENTATION(console);
1025 DEFSUBR(Fvalid_console_type_p);
1026 DEFSUBR(Fconsole_type_list);
1027 DEFSUBR(Fcdfw_console);
1028 DEFSUBR(Fselected_console);
1029 DEFSUBR(Fselect_console);
1031 DEFSUBR(Fconsole_live_p);
1032 DEFSUBR(Fconsole_type);
1033 DEFSUBR(Fconsole_name);
1034 DEFSUBR(Fconsole_connection);
1035 DEFSUBR(Ffind_console);
1036 DEFSUBR(Fget_console);
1037 DEFSUBR(Fdelete_console);
1038 DEFSUBR(Fconsole_list);
1039 DEFSUBR(Fconsole_device_list);
1040 DEFSUBR(Fconsole_enable_input);
1041 DEFSUBR(Fconsole_disable_input);
1042 DEFSUBR(Fconsole_on_window_system_p);
1043 DEFSUBR(Fsuspend_console);
1044 DEFSUBR(Fresume_console);
1046 DEFSUBR(Fsuspend_emacs);
1047 DEFSUBR(Fset_input_mode);
1048 DEFSUBR(Fcurrent_input_mode);
1050 defsymbol(&Qconsolep, "consolep");
1051 defsymbol(&Qconsole_live_p, "console-live-p");
1053 defsymbol(&Qcreate_console_hook, "create-console-hook");
1054 defsymbol(&Qdelete_console_hook, "delete-console-hook");
1056 defsymbol(&Qsuspend_hook, "suspend-hook");
1057 defsymbol(&Qsuspend_resume_hook, "suspend-resume-hook");
1060 static const struct lrecord_description cte_description_1[] = {
1061 {XD_LISP_OBJECT, offsetof(console_type_entry, symbol)},
1062 {XD_STRUCT_PTR, offsetof(console_type_entry, meths), 1,
1063 &console_methods_description},
1067 static const struct struct_description cte_description = {
1068 sizeof(console_type_entry),
1072 static const struct lrecord_description cted_description_1[] = {
1073 XD_DYNARR_DESC(console_type_entry_dynarr, &cte_description),
1077 const struct struct_description cted_description = {
1078 sizeof(console_type_entry_dynarr),
1082 static const struct lrecord_description console_methods_description_1[] = {
1083 {XD_LISP_OBJECT, offsetof(struct console_methods, symbol)},
1084 {XD_LISP_OBJECT, offsetof(struct console_methods, predicate_symbol)},
1086 offsetof(struct console_methods, image_conversion_list)},
1090 const struct struct_description console_methods_description = {
1091 sizeof(struct console_methods),
1092 console_methods_description_1
1095 void console_type_create(void)
1097 the_console_type_entry_dynarr = Dynarr_new(console_type_entry);
1098 dump_add_root_struct_ptr(&the_console_type_entry_dynarr,
1101 Vconsole_type_list = Qnil;
1102 staticpro(&Vconsole_type_list);
1104 /* Initialize the dead console type */
1105 INITIALIZE_CONSOLE_TYPE(dead, "dead", "console-dead-p");
1107 /* then reset the console-type lists, because `dead' is not really
1108 a valid console type */
1109 Dynarr_reset(the_console_type_entry_dynarr);
1110 Vconsole_type_list = Qnil;
1113 void reinit_vars_of_console(void)
1115 staticpro_nodump(&Vconsole_list);
1116 Vconsole_list = Qnil;
1117 staticpro_nodump(&Vselected_console);
1118 Vselected_console = Qnil;
1121 void vars_of_console(void)
1123 reinit_vars_of_console();
1125 DEFVAR_LISP("create-console-hook", &Vcreate_console_hook /*
1126 Function or functions to call when a console is created.
1127 One argument, the newly-created console.
1128 This is called after the first frame has been created, but before
1129 calling the `create-device-hook' or `create-frame-hook'.
1130 Note that in general the console will not be selected.
1132 Vcreate_console_hook = Qnil;
1134 DEFVAR_LISP("delete-console-hook", &Vdelete_console_hook /*
1135 Function or functions to call when a console is deleted.
1136 One argument, the to-be-deleted console.
1138 Vdelete_console_hook = Qnil;
1140 #ifdef HAVE_WINDOW_SYSTEM
1141 Fprovide(intern("window-system"));
1145 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
1146 #if defined HAVE_BDWGC && defined EF_USE_BDWGC
1148 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
1149 static const struct symbol_value_forward I_hate_C = \
1150 { /* struct symbol_value_forward */ \
1151 { /* struct symbol_value_magic */ \
1152 { /* struct lcrecord_header */ \
1153 { /* struct lrecord_header */ \
1154 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
1156 1, /* c_readonly bit */ \
1157 1 /* lisp_readonly bit */ \
1162 &(console_local_flags.field_name), \
1169 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) \
1170 - (char *)&console_local_flags); \
1172 defvar_magic (lname, &I_hate_C); \
1174 *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols))) \
1181 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
1182 static const struct symbol_value_forward I_hate_C = \
1183 { /* struct symbol_value_forward */ \
1184 { /* struct symbol_value_magic */ \
1185 { /* struct lcrecord_header */ \
1186 { /* struct lrecord_header */ \
1187 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
1189 1, /* c_readonly bit */ \
1190 1 /* lisp_readonly bit */ \
1196 &(console_local_flags.field_name), \
1203 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) \
1204 - (char *)&console_local_flags); \
1206 defvar_magic (lname, &I_hate_C); \
1208 *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols))) \
1215 #define DEFVAR_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
1216 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
1217 SYMVAL_SELECTED_CONSOLE_FORWARD, magicfun)
1218 #define DEFVAR_CONSOLE_LOCAL(lname, field_name) \
1219 DEFVAR_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
1220 #define DEFVAR_CONST_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
1221 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
1222 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, magicfun)
1223 #define DEFVAR_CONST_CONSOLE_LOCAL(lname, field_name) \
1224 DEFVAR_CONST_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
1226 #define DEFVAR_CONSOLE_DEFAULTS_MAGIC(lname, field_name, magicfun) \
1227 DEFVAR_SYMVAL_FWD(lname, &(console_local_flags.field_name), \
1228 SYMVAL_DEFAULT_CONSOLE_FORWARD, magicfun)
1229 #define DEFVAR_CONSOLE_DEFAULTS(lname, field_name) \
1230 DEFVAR_CONSOLE_DEFAULTS_MAGIC (lname, field_name, 0)
1232 static void nuke_all_console_slots(struct console *con, Lisp_Object zap)
1236 #define MARKED_SLOT(x) con->x = zap
1237 #include "conslots.h"
1241 static void common_init_complex_vars_of_console(void)
1243 /* Make sure all markable slots in console_defaults
1244 are initialized reasonably, so mark_console won't choke.
1246 struct console *defs =
1247 alloc_lcrecord_type(struct console, &lrecord_console);
1248 struct console *syms =
1249 alloc_lcrecord_type(struct console, &lrecord_console);
1251 staticpro_nodump(&Vconsole_defaults);
1252 staticpro_nodump(&Vconsole_local_symbols);
1253 XSETCONSOLE(Vconsole_defaults, defs);
1254 XSETCONSOLE(Vconsole_local_symbols, syms);
1256 nuke_all_console_slots(syms, Qnil);
1257 nuke_all_console_slots(defs, Qnil);
1259 /* Set up the non-nil default values of various console slots.
1260 Must do these before making the first console.
1262 /* #### Anything needed here? */
1265 /* 0 means var is always local. Default used only at creation.
1266 * -1 means var is always local. Default used only at reset and
1268 * -2 means there's no lisp variable corresponding to this slot
1269 * and the default is only used at creation.
1270 * -3 means no Lisp variable. Default used only at reset and creation.
1271 * >0 is mask. Var is local if ((console->local_var_flags & mask) != 0)
1272 * Otherwise default is used.
1274 * #### We don't currently ever reset console variables, so there
1275 * is no current distinction between 0 and -1, and between -2 and -3.
1277 Lisp_Object always_local_resettable = make_int(-1);
1279 #if 0 /* not used */
1280 Lisp_Object always_local_no_default = make_int(0);
1281 Lisp_Object resettable = make_int(-3);
1284 /* Assign the local-flags to the slots that have default values.
1285 The local flag is a bit that is used in the console
1286 to say that it has its own local value for the slot.
1287 The local flag bits are in the local_var_flags slot of the
1290 nuke_all_console_slots(&console_local_flags, make_int(-2));
1291 console_local_flags.defining_kbd_macro =
1292 always_local_resettable;
1293 console_local_flags.last_kbd_macro = always_local_resettable;
1294 console_local_flags.prefix_arg = always_local_resettable;
1295 console_local_flags.default_minibuffer_frame =
1296 always_local_resettable;
1297 console_local_flags.overriding_terminal_local_map =
1298 always_local_resettable;
1300 console_local_flags.tty_erase_char = always_local_resettable;
1303 console_local_flags.function_key_map = make_int(1);
1305 /* #### Warning, 0x4000000 (that's six zeroes) is the largest number
1306 currently allowable due to the XINT() handling of this value.
1307 With some rearrangement you can get 4 more bits. */
1311 #define CONSOLE_SLOTS_SIZE (offsetof (struct console, CONSOLE_SLOTS_LAST_NAME) - offsetof (struct console, CONSOLE_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
1312 #define CONSOLE_SLOTS_COUNT (CONSOLE_SLOTS_SIZE / sizeof (Lisp_Object))
1314 void reinit_complex_vars_of_console(void)
1316 struct console *defs, *syms;
1318 common_init_complex_vars_of_console();
1320 defs = XCONSOLE(Vconsole_defaults);
1321 syms = XCONSOLE(Vconsole_local_symbols);
1322 memcpy(&defs->CONSOLE_SLOTS_FIRST_NAME,
1323 console_defaults_saved_slots, CONSOLE_SLOTS_SIZE);
1324 memcpy(&syms->CONSOLE_SLOTS_FIRST_NAME,
1325 console_local_symbols_saved_slots, CONSOLE_SLOTS_SIZE);
1328 static const struct lrecord_description console_slots_description_1[] = {
1329 {XD_LISP_OBJECT_ARRAY, 0, CONSOLE_SLOTS_COUNT},
1333 static const struct struct_description console_slots_description = {
1335 console_slots_description_1
1338 void complex_vars_of_console(void)
1340 struct console *defs, *syms;
1342 common_init_complex_vars_of_console();
1344 defs = XCONSOLE(Vconsole_defaults);
1345 syms = XCONSOLE(Vconsole_local_symbols);
1346 console_defaults_saved_slots = &defs->CONSOLE_SLOTS_FIRST_NAME;
1347 console_local_symbols_saved_slots = &syms->CONSOLE_SLOTS_FIRST_NAME;
1348 dump_add_root_struct_ptr(&console_defaults_saved_slots,
1349 &console_slots_description);
1350 dump_add_root_struct_ptr(&console_local_symbols_saved_slots,
1351 &console_slots_description);
1353 DEFVAR_CONSOLE_DEFAULTS("default-function-key-map", function_key_map /*
1354 Default value of `function-key-map' for consoles that don't override it.
1355 This is the same as (default-value 'function-key-map).
1358 DEFVAR_CONSOLE_LOCAL("function-key-map", function_key_map /*
1359 Keymap mapping ASCII function key sequences onto their preferred forms.
1360 This allows Emacs to recognize function keys sent from ASCII
1361 terminals at any point in a key sequence.
1363 The `read-key-sequence' function replaces any subsequence bound by
1364 `function-key-map' with its binding. More precisely, when the active
1365 keymaps have no binding for the current key sequence but
1366 `function-key-map' binds a suffix of the sequence to a vector or string,
1367 `read-key-sequence' replaces the matching suffix with its binding, and
1368 continues with the new sequence. See `key-binding'.
1370 The events that come from bindings in `function-key-map' are not
1371 themselves looked up in `function-key-map'.
1373 For example, suppose `function-key-map' binds `ESC O P' to [f1].
1374 Typing `ESC O P' to `read-key-sequence' would return
1375 \[#<keypress-event f1>]. Typing `C-x ESC O P' would return
1376 \[#<keypress-event control-X> #<keypress-event f1>]. If [f1]
1377 were a prefix key, typing `ESC O P x' would return
1378 \[#<keypress-event f1> #<keypress-event x>].
1382 /* #### Should this somehow go to TTY data? How do we make it
1383 accessible from Lisp, then? */
1384 DEFVAR_CONSOLE_LOCAL("tty-erase-char", tty_erase_char /*
1385 The ERASE character as set by the user with stty.
1386 When this value cannot be determined or would be meaningless (on non-TTY
1387 consoles, for example), it is set to nil.
1391 /* While this should be const it can't be because some things
1392 (i.e. edebug) do manipulate it. */
1393 DEFVAR_CONSOLE_LOCAL("defining-kbd-macro", defining_kbd_macro /*
1394 Non-nil while a keyboard macro is being defined. Don't set this!
1397 DEFVAR_CONSOLE_LOCAL("last-kbd-macro", last_kbd_macro /*
1398 Last keyboard macro defined, as a vector of events; nil if none defined.
1401 DEFVAR_CONSOLE_LOCAL("prefix-arg", prefix_arg /*
1402 The value of the prefix argument for the next editing command.
1403 It may be a number, or the symbol `-' for just a minus sign as arg,
1404 or a list whose car is a number for just one or more C-U's
1405 or nil if no argument has been specified.
1407 You cannot examine this variable to find the argument for this command
1408 since it has been set to nil by the time you can look.
1409 Instead, you should use the variable `current-prefix-arg', although
1410 normally commands can get this prefix argument with (interactive "P").
1413 DEFVAR_CONSOLE_LOCAL("default-minibuffer-frame", default_minibuffer_frame /*
1414 Minibufferless frames use this frame's minibuffer.
1416 Emacs cannot create minibufferless frames unless this is set to an
1417 appropriate surrogate.
1419 SXEmacs consults this variable only when creating minibufferless
1420 frames; once the frame is created, it sticks with its assigned
1421 minibuffer, no matter what this variable is set to. This means that
1422 this variable doesn't necessarily say anything meaningful about the
1423 current set of frames, or where the minibuffer is currently being
1427 DEFVAR_CONSOLE_LOCAL("overriding-terminal-local-map", overriding_terminal_local_map /*
1428 Keymap that overrides all other local keymaps, for the selected console only.
1429 If this variable is non-nil, it is used as a keymap instead of the
1430 buffer's local map, and the minor mode keymaps and text property keymaps.
1433 /* Check for DEFVAR_CONSOLE_LOCAL without initializing the corresponding
1434 slot of console_local_flags and vice-versa. Must be done after all
1435 DEFVAR_CONSOLE_LOCAL() calls. */
1436 #define MARKED_SLOT(slot) \
1437 if ((XINT (console_local_flags.slot) != -2 && \
1438 XINT (console_local_flags.slot) != -3) \
1439 != !(NILP (XCONSOLE (Vconsole_local_symbols)->slot))) \
1441 #include "conslots.h"