2 Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
3 Copyright (C) 1996 Ben Wing.
5 This file is part of XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: Not in FSF. */
24 /* Written by Ben Wing. */
30 #include "console-tty.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.
86 struct console console_local_flags;
88 /* This structure holds the names of symbols whose values may be
89 console-local. It is indexed and accessed in the same way as the above. */
90 static Lisp_Object Vconsole_local_symbols;
91 static void *console_local_symbols_saved_slots;
93 DEFINE_CONSOLE_TYPE (dead);
95 Lisp_Object Vconsole_type_list;
97 console_type_entry_dynarr *the_console_type_entry_dynarr;
101 mark_console (Lisp_Object obj)
103 struct console *con = XCONSOLE (obj);
105 #define MARKED_SLOT(x) mark_object (con->x)
106 #include "conslots.h"
109 /* Can be zero for Vconsole_defaults, Vconsole_local_symbols */
112 mark_object (con->conmeths->symbol);
113 MAYBE_CONMETH (con, mark_console, (con));
120 print_console (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
122 struct console *con = XCONSOLE (obj);
126 error ("printing unreadable object #<console %s 0x%x>",
127 XSTRING_DATA (con->name), con->header.uid);
129 sprintf (buf, "#<%s-console", !CONSOLE_LIVE_P (con) ? "dead" :
130 CONSOLE_TYPE_NAME (con));
131 write_c_string (buf, printcharfun);
132 if (CONSOLE_LIVE_P (con) && !NILP (CONSOLE_CONNECTION (con)))
134 write_c_string (" on ", printcharfun);
135 print_internal (CONSOLE_CONNECTION (con), printcharfun, 1);
137 sprintf (buf, " 0x%x>", con->header.uid);
138 write_c_string (buf, printcharfun);
141 DEFINE_LRECORD_IMPLEMENTATION ("console", console,
142 mark_console, print_console, 0, 0, 0, 0,
145 static struct console *
146 allocate_console (void)
149 struct console *con = alloc_lcrecord_type (struct console, &lrecord_console);
152 copy_lcrecord (con, XCONSOLE (Vconsole_defaults));
154 XSETCONSOLE (console, con);
157 con->quit_char = 7; /* C-g */
158 con->command_builder = allocate_command_builder (console);
159 con->function_key_map = Fmake_sparse_keymap (Qnil);
166 decode_console (Lisp_Object console)
169 console = Fselected_console ();
170 /* quietly accept devices and frames for the console arg */
171 if (DEVICEP (console) || FRAMEP (console))
172 console = DEVICE_CONSOLE (decode_device (console));
173 CHECK_LIVE_CONSOLE (console);
174 return XCONSOLE (console);
178 struct console_methods *
179 decode_console_type (Lisp_Object type, Error_behavior errb)
183 for (i = 0; i < Dynarr_length (the_console_type_entry_dynarr); i++)
184 if (EQ (type, Dynarr_at (the_console_type_entry_dynarr, i).symbol))
185 return Dynarr_at (the_console_type_entry_dynarr, i).meths;
187 maybe_signal_simple_error ("Invalid console type", type, Qconsole, errb);
193 valid_console_type_p (Lisp_Object type)
195 return decode_console_type (type, ERROR_ME_NOT) != 0;
198 DEFUN ("valid-console-type-p", Fvalid_console_type_p, 1, 1, 0, /*
199 Return t if CONSOLE-TYPE is a valid console type.
200 Valid types are 'x, 'tty, and 'stream.
204 return valid_console_type_p (console_type) ? Qt : Qnil;
207 DEFUN ("console-type-list", Fconsole_type_list, 0, 0, 0, /*
208 Return a list of valid console types.
212 return Fcopy_sequence (Vconsole_type_list);
215 DEFUN ("cdfw-console", Fcdfw_console, 1, 1, 0, /*
216 Given a console, device, frame, or window, return the associated console.
217 Return nil otherwise.
221 return CDFW_CONSOLE (object);
225 DEFUN ("selected-console", Fselected_console, 0, 0, 0, /*
226 Return the console which is currently active.
230 return Vselected_console;
233 /* Called from selected_device_1(), called from selected_frame_1(),
234 called from Fselect_window() */
236 select_console_1 (Lisp_Object console)
238 /* perhaps this should do something more complicated */
239 Vselected_console = console;
241 /* #### Schedule this to be removed in 19.14 */
242 #ifdef HAVE_X_WINDOWS
243 if (CONSOLE_X_P (XCONSOLE (console)))
248 if (CONSOLE_GTK_P (XCONSOLE (console)))
249 Vwindow_system = Qgtk;
252 #ifdef HAVE_MS_WINDOWS
253 if (CONSOLE_MSWINDOWS_P (XCONSOLE (console)))
254 Vwindow_system = Qmswindows;
257 Vwindow_system = Qnil;
260 DEFUN ("select-console", Fselect_console, 1, 1, 0, /*
261 Select the console CONSOLE.
262 Subsequent editing commands apply to its selected device, selected frame,
263 and selected window. The selection of CONSOLE lasts until the next time
264 the user does something to select a different console, or until the next
265 time this function is called.
271 CHECK_LIVE_CONSOLE (console);
273 device = CONSOLE_SELECTED_DEVICE (XCONSOLE (console));
276 struct device *d = XDEVICE (device);
277 Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
280 struct frame *f = XFRAME(frame);
281 Fselect_window (FRAME_SELECTED_WINDOW (f), Qnil);
284 error ("Can't select console with no frames.");
287 error ("Can't select a console with no devices");
292 set_console_last_nonminibuf_frame (struct console *con,
295 con->last_nonminibuf_frame = frame;
298 DEFUN ("consolep", Fconsolep, 1, 1, 0, /*
299 Return non-nil if OBJECT is a console.
303 return CONSOLEP (object) ? Qt : Qnil;
306 DEFUN ("console-live-p", Fconsole_live_p, 1, 1, 0, /*
307 Return non-nil if OBJECT is a console that has not been deleted.
311 return CONSOLEP (object) && CONSOLE_LIVE_P (XCONSOLE (object)) ? Qt : Qnil;
314 DEFUN ("console-type", Fconsole_type, 0, 1, 0, /*
315 Return the console type (e.g. `x' or `tty') of CONSOLE.
316 Value is `tty' for a tty console (a character-only terminal),
317 `x' for a console that is an X display,
318 `mswindows' for a console that is a Windows NT/95/97 connection,
319 `pc' for a console that is a direct-write MS-DOS connection (not yet
321 `stream' for a stream console (which acts like a stdio stream), and
322 `dead' for a deleted console.
326 /* don't call decode_console() because we want to allow for dead
329 console = Fselected_console ();
330 CHECK_CONSOLE (console);
331 return CONSOLE_TYPE (XCONSOLE (console));
334 DEFUN ("console-name", Fconsole_name, 0, 1, 0, /*
335 Return the name of CONSOLE.
339 return CONSOLE_NAME (decode_console (console));
342 DEFUN ("console-connection", Fconsole_connection, 0, 1, 0, /*
343 Return the connection of the specified console.
344 CONSOLE defaults to the selected console if omitted.
348 return CONSOLE_CONNECTION (decode_console (console));
352 make_console (struct console *con)
355 XSETCONSOLE (console, con);
360 semi_canonicalize_console_connection (struct console_methods *meths,
361 Lisp_Object name, Error_behavior errb)
363 if (HAS_CONTYPE_METH_P (meths, semi_canonicalize_console_connection))
364 return CONTYPE_METH (meths, semi_canonicalize_console_connection,
367 return CONTYPE_METH_OR_GIVEN (meths, canonicalize_console_connection,
372 canonicalize_console_connection (struct console_methods *meths,
373 Lisp_Object name, Error_behavior errb)
375 if (HAS_CONTYPE_METH_P (meths, canonicalize_console_connection))
376 return CONTYPE_METH (meths, canonicalize_console_connection,
379 return CONTYPE_METH_OR_GIVEN (meths, semi_canonicalize_console_connection,
384 find_console_of_type (struct console_methods *meths, Lisp_Object canon)
388 CONSOLE_LOOP (concons)
390 Lisp_Object console = XCAR (concons);
392 if (EQ (CONMETH_TYPE (meths), CONSOLE_TYPE (XCONSOLE (console)))
393 && internal_equal (CONSOLE_CANON_CONNECTION (XCONSOLE (console)),
401 DEFUN ("find-console", Ffind_console, 1, 2, 0, /*
402 Look for an existing console attached to connection CONNECTION.
403 Return the console if found; otherwise, return nil.
405 If TYPE is specified, only return consoles of that type; otherwise,
406 return consoles of any type. (It is possible, although unlikely,
407 that two consoles of different types could have the same connection
408 name; in such a case, the first console found is returned.)
412 Lisp_Object canon = Qnil;
419 struct console_methods *conmeths = decode_console_type (type, ERROR_ME);
420 canon = canonicalize_console_connection (conmeths, connection,
422 if (UNBOUNDP (canon))
423 RETURN_UNGCPRO (Qnil);
425 RETURN_UNGCPRO (find_console_of_type (conmeths, canon));
431 for (i = 0; i < Dynarr_length (the_console_type_entry_dynarr); i++)
433 struct console_methods *conmeths =
434 Dynarr_at (the_console_type_entry_dynarr, i).meths;
435 canon = canonicalize_console_connection (conmeths, connection,
437 if (!UNBOUNDP (canon))
439 Lisp_Object console = find_console_of_type (conmeths, canon);
441 RETURN_UNGCPRO (console);
445 RETURN_UNGCPRO (Qnil);
449 DEFUN ("get-console", Fget_console, 1, 2, 0, /*
450 Look for an existing console attached to connection CONNECTION.
451 Return the console if found; otherwise, signal an error.
453 If TYPE is specified, only return consoles of that type; otherwise,
454 return consoles of any type. (It is possible, although unlikely,
455 that two consoles of different types could have the same connection
456 name; in such a case, the first console found is returned.)
460 Lisp_Object console = Ffind_console (connection, type);
464 signal_simple_error ("No such console", connection);
466 signal_simple_error_2 ("No such console", type, connection);
472 create_console (Lisp_Object name, Lisp_Object type, Lisp_Object connection,
475 /* This function can GC */
480 console = Ffind_console (connection, type);
484 con = allocate_console ();
485 XSETCONSOLE (console, con);
489 con->conmeths = decode_console_type (type, ERROR_ME);
491 CONSOLE_NAME (con) = name;
492 CONSOLE_CONNECTION (con) =
493 semi_canonicalize_console_connection (con->conmeths, connection,
495 CONSOLE_CANON_CONNECTION (con) =
496 canonicalize_console_connection (con->conmeths, connection,
499 MAYBE_CONMETH (con, init_console, (con, props));
501 /* Do it this way so that the console list is in order of creation */
502 Vconsole_list = nconc2 (Vconsole_list, Fcons (console, Qnil));
504 if (CONMETH_OR_GIVEN (con, initially_selected_for_input, (con), 0))
505 event_stream_select_console (con);
512 add_entry_to_console_type_list (Lisp_Object symbol,
513 struct console_methods *meths)
515 struct console_type_entry entry;
517 entry.symbol = symbol;
519 Dynarr_add (the_console_type_entry_dynarr, entry);
520 Vconsole_type_list = Fcons (symbol, Vconsole_type_list);
523 /* find a console other than the selected one. Prefer non-stream
524 consoles over stream consoles. */
527 find_other_console (Lisp_Object console)
531 /* look for a non-stream console */
532 CONSOLE_LOOP (concons)
534 Lisp_Object con = XCAR (concons);
535 if (!CONSOLE_STREAM_P (XCONSOLE (con))
536 && !EQ (con, console)
537 && !NILP (CONSOLE_SELECTED_DEVICE (XCONSOLE (con)))
538 && !NILP (DEVICE_SELECTED_FRAME
539 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (con))))))
543 return XCAR (concons);
545 /* OK, now look for a stream console */
546 CONSOLE_LOOP (concons)
548 Lisp_Object con = XCAR (concons);
549 if (!EQ (con, console)
550 && !NILP (CONSOLE_SELECTED_DEVICE (XCONSOLE (con)))
551 && !NILP (DEVICE_SELECTED_FRAME
552 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (con))))))
556 return XCAR (concons);
558 /* Sorry, there ain't none */
563 find_nonminibuffer_frame_not_on_console_predicate (Lisp_Object frame,
568 VOID_TO_LISP (console, closure);
569 if (FRAME_MINIBUF_ONLY_P (XFRAME (frame)))
571 if (EQ (console, FRAME_CONSOLE (XFRAME (frame))))
577 find_nonminibuffer_frame_not_on_console (Lisp_Object console)
579 return find_some_frame (find_nonminibuffer_frame_not_on_console_predicate,
580 LISP_TO_VOID (console));
583 /* Delete console CON.
585 If FORCE is non-zero, allow deletion of the only frame.
587 If CALLED_FROM_KILL_EMACS is non-zero, then, if
588 deleting the last console, just delete it,
589 instead of calling `save-buffers-kill-emacs'.
591 If FROM_IO_ERROR is non-zero, then the console is gone due
592 to an I/O error. This affects what happens if we exit
593 (we do an emergency exit instead of `save-buffers-kill-emacs'.)
597 delete_console_internal (struct console *con, int force,
598 int called_from_kill_emacs, int from_io_error)
600 /* This function can GC */
604 /* OK to delete an already-deleted console. */
605 if (!CONSOLE_LIVE_P (con))
608 XSETCONSOLE (console, con);
611 if (!called_from_kill_emacs)
615 if ((XINT (Flength (Vconsole_list)) == 1)
616 /* if we just created the console, it might not be listed,
618 && !NILP (memq_no_quit (console, Vconsole_list)))
620 /* If there aren't any nonminibuffer frames that would
621 be left, then exit. */
622 else if (NILP (find_nonminibuffer_frame_not_on_console (console)))
628 error ("Attempt to delete the only frame");
629 else if (from_io_error)
631 /* Mayday mayday! We're going down! */
632 stderr_out (" Autosaving and exiting...\n");
633 Vwindow_system = Qnil; /* let it lie! */
634 preparing_for_armageddon = 1;
635 Fkill_emacs (make_int (70));
639 call0 (Qsave_buffers_kill_emacs);
641 /* If we get here, the user said they didn't want
642 to exit, so don't. */
648 /* Breathe a sigh of relief. We're still alive. */
651 Lisp_Object frmcons, devcons;
653 /* First delete all frames without their own minibuffers,
654 to avoid errors coming from attempting to delete a frame
655 that is a surrogate for another frame.
657 We don't set "called_from_delete_console" because we want the
658 device to go ahead and get deleted if we delete the last frame
659 on a device. We won't run into trouble here because for any
660 frame without a minibuffer, there has to be another one on
661 the same console with a minibuffer, and we're not deleting that,
662 so delete_console_internal() won't get recursively called.
664 WRONG! With surrogate minibuffers this isn't true. Frames
665 with only a minibuffer are not enough to prevent
666 delete_frame_internal from triggering a device deletion. */
667 CONSOLE_FRAME_LOOP_NO_BREAK (frmcons, devcons, con)
669 struct frame *f = XFRAME (XCAR (frmcons));
670 /* delete_frame_internal() might do anything such as run hooks,
672 if (FRAME_LIVE_P (f) && !FRAME_HAS_MINIBUF_P (f))
673 delete_frame_internal (f, 1, 1, from_io_error);
675 if (!CONSOLE_LIVE_P (con)) /* make sure the delete-*-hook didn't
676 go ahead and delete anything */
683 CONSOLE_DEVICE_LOOP (devcons, con)
685 struct device *d = XDEVICE (XCAR (devcons));
686 /* delete_device_internal() might do anything such as run hooks,
688 if (DEVICE_LIVE_P (d))
689 delete_device_internal (d, 1, 1, from_io_error);
690 if (!CONSOLE_LIVE_P (con)) /* make sure the delete-*-hook didn't
691 go ahead and delete anything */
699 CONSOLE_SELECTED_DEVICE (con) = Qnil;
701 /* try to select another console */
703 if (EQ (console, Fselected_console ()))
705 Lisp_Object other_dev = find_other_console (console);
706 if (!NILP (other_dev))
707 Fselect_console (other_dev);
711 Vselected_console = Qnil;
712 Vwindow_system = Qnil;
716 if (con->input_enabled)
717 event_stream_unselect_console (con);
719 MAYBE_CONMETH (con, delete_console, (con));
721 Vconsole_list = delq_no_quit (console, Vconsole_list);
722 RESET_CHANGED_SET_FLAGS;
723 con->conmeths = dead_console_methods;
729 io_error_delete_console (Lisp_Object console)
731 delete_console_internal (XCONSOLE (console), 1, 0, 1);
734 DEFUN ("delete-console", Fdelete_console, 1, 2, 0, /*
735 Delete CONSOLE, permanently eliminating it from use.
736 Normally, you cannot delete the last non-minibuffer-only frame (you must
737 use `save-buffers-kill-emacs' or `kill-emacs'). However, if optional
738 second argument FORCE is non-nil, you can delete the last frame. (This
739 will automatically call `save-buffers-kill-emacs'.)
743 CHECK_CONSOLE (console);
744 delete_console_internal (XCONSOLE (console), !NILP (force), 0, 0);
748 DEFUN ("console-list", Fconsole_list, 0, 0, 0, /*
749 Return a list of all consoles.
753 return Fcopy_sequence (Vconsole_list);
756 DEFUN ("console-device-list", Fconsole_device_list, 0, 1, 0, /*
757 Return a list of all devices on CONSOLE.
758 If CONSOLE is nil, the selected console is used.
762 return Fcopy_sequence (CONSOLE_DEVICE_LIST (decode_console (console)));
765 DEFUN ("console-enable-input", Fconsole_enable_input, 1, 1, 0, /*
766 Enable input on console CONSOLE.
770 struct console *con = decode_console (console);
771 if (!con->input_enabled)
772 event_stream_select_console (con);
776 DEFUN ("console-disable-input", Fconsole_disable_input, 1, 1, 0, /*
777 Disable input on console CONSOLE.
781 struct console *con = decode_console (console);
782 if (con->input_enabled)
783 event_stream_unselect_console (con);
787 DEFUN ("console-on-window-system-p", Fconsole_on_window_system_p, 0, 1, 0, /*
788 Return t if CONSOLE is on a window system.
789 If CONSOLE is nil, the selected console is used.
790 This generally means that there is support for the mouse, the menubar,
791 the toolbar, glyphs, etc.
795 Lisp_Object type = CONSOLE_TYPE (decode_console (console));
797 return !EQ (type, Qtty) && !EQ (type, Qstream) ? Qt : Qnil;
802 /**********************************************************************/
803 /* Miscellaneous low-level functions */
804 /**********************************************************************/
807 unwind_init_sys_modes (Lisp_Object console)
809 reinit_initial_console ();
811 if (!no_redraw_on_reenter &&
812 CONSOLEP (console) &&
813 CONSOLE_LIVE_P (XCONSOLE (console)))
816 XFRAME (DEVICE_SELECTED_FRAME
817 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (console)))));
818 MARK_FRAME_CHANGED (f);
823 DEFUN ("suspend-emacs", Fsuspend_emacs, 0, 1, "", /*
824 Stop Emacs and return to superior process. You can resume later.
825 On systems that don't have job control, run a subshell instead.
827 If optional arg STUFFSTRING is non-nil, its characters are stuffed
828 to be read as terminal input by Emacs's superior shell.
830 Before suspending, run the normal hook `suspend-hook'.
831 After resumption run the normal hook `suspend-resume-hook'.
833 Some operating systems cannot stop the Emacs process and resume it later.
834 On such systems, Emacs will start a subshell and wait for it to exit.
838 int speccount = specpdl_depth ();
841 if (!NILP (stuffstring))
842 CHECK_STRING (stuffstring);
843 GCPRO1 (stuffstring);
845 /* There used to be a check that the initial console is TTY.
846 This is bogus. Even checking to see whether any console
847 is a controlling terminal is not correct -- maybe
848 the user used the -t option or something. If we want to
849 suspend, then we suspend. Period. */
851 /* Call value of suspend-hook. */
852 run_hook (Qsuspend_hook);
854 reset_initial_console ();
855 /* sys_suspend can get an error if it tries to fork a subshell
856 and the system resources aren't available for that. */
857 record_unwind_protect (unwind_init_sys_modes, Vcontrolling_terminal);
858 stuff_buffered_input (stuffstring);
860 /* the console is un-reset inside of the unwind-protect. */
861 unbind_to (speccount, Qnil);
864 /* It is possible that a size change occurred while we were
865 suspended. Assume one did just to be safe. It won't hurt
866 anything if one didn't. */
867 asynch_device_change_pending++;
870 /* Call value of suspend-resume-hook
871 if it is bound and value is non-nil. */
872 run_hook (Qsuspend_resume_hook);
878 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
879 Then in any case stuff anything Emacs has read ahead and not used. */
882 stuff_buffered_input (Lisp_Object stuffstring)
884 /* stuff_char works only in BSD, versions 4.2 and up. */
885 #if defined (BSD) && defined(HAVE_TTY)
886 if (!CONSOLEP (Vcontrolling_terminal) ||
887 !CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
890 if (STRINGP (stuffstring))
895 TO_EXTERNAL_FORMAT (LISP_STRING, stuffstring,
899 stuff_char (XCONSOLE (Vcontrolling_terminal), *p++);
900 stuff_char (XCONSOLE (Vcontrolling_terminal), '\n');
902 /* Anything we have read ahead, put back for the shell to read. */
903 # if 0 /* oh, who cares about this silliness */
904 while (kbd_fetch_ptr != kbd_store_ptr)
906 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
907 kbd_fetch_ptr = kbd_buffer;
908 stuff_char (XCONSOLE (Vcontrolling_terminal), *kbd_fetch_ptr++);
911 #endif /* BSD && HAVE_TTY */
914 DEFUN ("suspend-console", Fsuspend_console, 0, 1, "", /*
915 Suspend a console. For tty consoles, it sends a signal to suspend
916 the process in charge of the tty, and removes the devices and
917 frames of that console from the display.
919 If optional arg CONSOLE is non-nil, it is the console to be suspended.
920 Otherwise it is assumed to be the selected console.
922 Some operating systems cannot stop processes and resume them later.
923 On such systems, who knows what will happen.
928 struct console *con = decode_console (console);
930 if (CONSOLE_TTY_P (con))
933 * hide all the unhidden frames so the display code won't update
934 * them while the console is suspended.
936 Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
939 struct device *d = XDEVICE (device);
940 Lisp_Object frame_list = DEVICE_FRAME_LIST (d);
941 while (CONSP (frame_list))
943 struct frame *f = XFRAME (XCAR (frame_list));
944 if (FRAME_REPAINT_P (f))
946 frame_list = XCDR (frame_list);
949 reset_one_console (con);
950 event_stream_unselect_console (con);
951 sys_suspend_process (XINT (Fconsole_tty_controlling_process (console)));
953 #endif /* HAVE_TTY */
958 DEFUN ("resume-console", Fresume_console, 1, 1, "", /*
959 Re-initialize a previously suspended console.
960 For tty consoles, do stuff to the tty to make it sane again.
965 struct console *con = decode_console (console);
967 if (CONSOLE_TTY_P (con))
969 /* raise the selected frame */
970 Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
973 struct device *d = XDEVICE (device);
974 Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
977 /* force the frame to be cleared */
978 SET_FRAME_CLEAR (XFRAME (frame));
979 Fraise_frame (frame);
982 init_one_console (con);
983 event_stream_select_console (con);
985 /* The same as in Fsuspend_emacs: it is possible that a size
986 change occurred while we were suspended. Assume one did just
987 to be safe. It won't hurt anything if one didn't. */
988 asynch_device_change_pending++;
991 #endif /* HAVE_TTY */
996 DEFUN ("set-input-mode", Fset_input_mode, 3, 5, 0, /*
997 Set mode of reading keyboard input.
998 First arg is ignored, for backward compatibility.
999 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
1000 (no effect except in CBREAK mode).
1001 Third arg META t means accept 8-bit input (for a Meta key).
1002 META nil means ignore the top bit, on the assumption it is parity.
1003 Otherwise, accept 8-bit input and don't use the top bit for Meta.
1004 First three arguments only apply to TTY consoles.
1005 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
1006 Optional fifth arg CONSOLE specifies console to make changes to; nil means
1007 the selected console.
1008 See also `current-input-mode'.
1010 (ignored, flow, meta, quit, console))
1012 struct console *con = decode_console (console);
1013 int meta_key = (!CONSOLE_TTY_P (con) ? 1 :
1014 EQ (meta, Qnil) ? 0 :
1020 CHECK_CHAR_COERCE_INT (quit);
1021 CONSOLE_QUIT_CHAR (con) =
1022 ((unsigned int) XCHAR (quit)) & (meta_key ? 0377 : 0177);
1026 if (CONSOLE_TTY_P (con))
1028 reset_one_console (con);
1029 TTY_FLAGS (con).flow_control = !NILP (flow);
1030 TTY_FLAGS (con).meta_key = meta_key;
1031 init_one_console (con);
1032 MARK_FRAME_CHANGED (XFRAME (CONSOLE_SELECTED_FRAME (con)));
1039 DEFUN ("current-input-mode", Fcurrent_input_mode, 0, 1, 0, /*
1040 Return information about the way Emacs currently reads keyboard input.
1041 Optional arg CONSOLE specifies console to return information about; nil means
1042 the selected console.
1043 The value is a list of the form (nil FLOW META QUIT), where
1044 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
1045 terminal; this does not apply if Emacs uses interrupt-driven input.
1046 META is t if accepting 8-bit input with 8th bit as Meta flag.
1047 META nil means ignoring the top bit, on the assumption it is parity.
1048 META is neither t nor nil if accepting 8-bit input and using
1049 all 8 bits as the character code.
1050 QUIT is the character Emacs currently uses to quit.
1051 FLOW, and META are only meaningful for TTY consoles.
1052 The elements of this list correspond to the arguments of
1057 struct console *con = decode_console (console);
1058 Lisp_Object flow, meta, quit;
1061 flow = CONSOLE_TTY_P (con) && TTY_FLAGS (con).flow_control ? Qt : Qnil;
1062 meta = (!CONSOLE_TTY_P (con) ? Qt :
1063 TTY_FLAGS (con).meta_key == 1 ? Qt :
1064 TTY_FLAGS (con).meta_key == 2 ? Qzero :
1070 quit = make_char (CONSOLE_QUIT_CHAR (con));
1072 return list4 (Qnil, flow, meta, quit);
1076 /************************************************************************/
1077 /* initialization */
1078 /************************************************************************/
1081 syms_of_console (void)
1083 INIT_LRECORD_IMPLEMENTATION (console);
1085 DEFSUBR (Fvalid_console_type_p);
1086 DEFSUBR (Fconsole_type_list);
1087 DEFSUBR (Fcdfw_console);
1088 DEFSUBR (Fselected_console);
1089 DEFSUBR (Fselect_console);
1090 DEFSUBR (Fconsolep);
1091 DEFSUBR (Fconsole_live_p);
1092 DEFSUBR (Fconsole_type);
1093 DEFSUBR (Fconsole_name);
1094 DEFSUBR (Fconsole_connection);
1095 DEFSUBR (Ffind_console);
1096 DEFSUBR (Fget_console);
1097 DEFSUBR (Fdelete_console);
1098 DEFSUBR (Fconsole_list);
1099 DEFSUBR (Fconsole_device_list);
1100 DEFSUBR (Fconsole_enable_input);
1101 DEFSUBR (Fconsole_disable_input);
1102 DEFSUBR (Fconsole_on_window_system_p);
1103 DEFSUBR (Fsuspend_console);
1104 DEFSUBR (Fresume_console);
1106 DEFSUBR (Fsuspend_emacs);
1107 DEFSUBR (Fset_input_mode);
1108 DEFSUBR (Fcurrent_input_mode);
1110 defsymbol (&Qconsolep, "consolep");
1111 defsymbol (&Qconsole_live_p, "console-live-p");
1113 defsymbol (&Qcreate_console_hook, "create-console-hook");
1114 defsymbol (&Qdelete_console_hook, "delete-console-hook");
1116 defsymbol (&Qsuspend_hook, "suspend-hook");
1117 defsymbol (&Qsuspend_resume_hook, "suspend-resume-hook");
1120 static const struct lrecord_description cte_description_1[] = {
1121 { XD_LISP_OBJECT, offsetof (console_type_entry, symbol) },
1122 { XD_STRUCT_PTR, offsetof (console_type_entry, meths), 1, &console_methods_description },
1126 static const struct struct_description cte_description = {
1127 sizeof (console_type_entry),
1131 static const struct lrecord_description cted_description_1[] = {
1132 XD_DYNARR_DESC (console_type_entry_dynarr, &cte_description),
1136 const struct struct_description cted_description = {
1137 sizeof (console_type_entry_dynarr),
1141 static const struct lrecord_description console_methods_description_1[] = {
1142 { XD_LISP_OBJECT, offsetof (struct console_methods, symbol) },
1143 { XD_LISP_OBJECT, offsetof (struct console_methods, predicate_symbol) },
1144 { XD_LISP_OBJECT, offsetof (struct console_methods, image_conversion_list) },
1148 const struct struct_description console_methods_description = {
1149 sizeof (struct console_methods),
1150 console_methods_description_1
1155 console_type_create (void)
1157 the_console_type_entry_dynarr = Dynarr_new (console_type_entry);
1158 dump_add_root_struct_ptr (&the_console_type_entry_dynarr, &cted_description);
1160 Vconsole_type_list = Qnil;
1161 staticpro (&Vconsole_type_list);
1163 /* Initialize the dead console type */
1164 INITIALIZE_CONSOLE_TYPE (dead, "dead", "console-dead-p");
1166 /* then reset the console-type lists, because `dead' is not really
1167 a valid console type */
1168 Dynarr_reset (the_console_type_entry_dynarr);
1169 Vconsole_type_list = Qnil;
1173 reinit_vars_of_console (void)
1175 staticpro_nodump (&Vconsole_list);
1176 Vconsole_list = Qnil;
1177 staticpro_nodump (&Vselected_console);
1178 Vselected_console = Qnil;
1182 vars_of_console (void)
1184 reinit_vars_of_console ();
1186 DEFVAR_LISP ("create-console-hook", &Vcreate_console_hook /*
1187 Function or functions to call when a console is created.
1188 One argument, the newly-created console.
1189 This is called after the first frame has been created, but before
1190 calling the `create-device-hook' or `create-frame-hook'.
1191 Note that in general the console will not be selected.
1193 Vcreate_console_hook = Qnil;
1195 DEFVAR_LISP ("delete-console-hook", &Vdelete_console_hook /*
1196 Function or functions to call when a console is deleted.
1197 One argument, the to-be-deleted console.
1199 Vdelete_console_hook = Qnil;
1201 #ifdef HAVE_WINDOW_SYSTEM
1202 Fprovide (intern ("window-system"));
1206 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
1207 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magicfun) do { \
1208 static const struct symbol_value_forward I_hate_C = \
1209 { /* struct symbol_value_forward */ \
1210 { /* struct symbol_value_magic */ \
1211 { /* struct lcrecord_header */ \
1212 { /* struct lrecord_header */ \
1213 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
1215 1, /* c_readonly bit */ \
1216 1 /* lisp_readonly bit */ \
1222 &(console_local_flags.field_name), \
1229 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) \
1230 - (char *)&console_local_flags); \
1232 defvar_magic (lname, &I_hate_C); \
1234 *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols))) \
1239 #define DEFVAR_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
1240 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
1241 SYMVAL_SELECTED_CONSOLE_FORWARD, magicfun)
1242 #define DEFVAR_CONSOLE_LOCAL(lname, field_name) \
1243 DEFVAR_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
1244 #define DEFVAR_CONST_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
1245 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
1246 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, magicfun)
1247 #define DEFVAR_CONST_CONSOLE_LOCAL(lname, field_name) \
1248 DEFVAR_CONST_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
1250 #define DEFVAR_CONSOLE_DEFAULTS_MAGIC(lname, field_name, magicfun) \
1251 DEFVAR_SYMVAL_FWD(lname, &(console_local_flags.field_name), \
1252 SYMVAL_DEFAULT_CONSOLE_FORWARD, magicfun)
1253 #define DEFVAR_CONSOLE_DEFAULTS(lname, field_name) \
1254 DEFVAR_CONSOLE_DEFAULTS_MAGIC (lname, field_name, 0)
1257 nuke_all_console_slots (struct console *con, Lisp_Object zap)
1259 zero_lcrecord (con);
1261 #define MARKED_SLOT(x) con->x = zap
1262 #include "conslots.h"
1267 common_init_complex_vars_of_console (void)
1269 /* Make sure all markable slots in console_defaults
1270 are initialized reasonably, so mark_console won't choke.
1272 struct console *defs = alloc_lcrecord_type (struct console, &lrecord_console);
1273 struct console *syms = alloc_lcrecord_type (struct console, &lrecord_console);
1275 staticpro_nodump (&Vconsole_defaults);
1276 staticpro_nodump (&Vconsole_local_symbols);
1277 XSETCONSOLE (Vconsole_defaults, defs);
1278 XSETCONSOLE (Vconsole_local_symbols, syms);
1280 nuke_all_console_slots (syms, Qnil);
1281 nuke_all_console_slots (defs, Qnil);
1283 /* Set up the non-nil default values of various console slots.
1284 Must do these before making the first console.
1286 /* #### Anything needed here? */
1289 /* 0 means var is always local. Default used only at creation.
1290 * -1 means var is always local. Default used only at reset and
1292 * -2 means there's no lisp variable corresponding to this slot
1293 * and the default is only used at creation.
1294 * -3 means no Lisp variable. Default used only at reset and creation.
1295 * >0 is mask. Var is local if ((console->local_var_flags & mask) != 0)
1296 * Otherwise default is used.
1298 * #### We don't currently ever reset console variables, so there
1299 * is no current distinction between 0 and -1, and between -2 and -3.
1301 Lisp_Object always_local_resettable = make_int (-1);
1303 #if 0 /* not used */
1304 Lisp_Object always_local_no_default = make_int (0);
1305 Lisp_Object resettable = make_int (-3);
1308 /* Assign the local-flags to the slots that have default values.
1309 The local flag is a bit that is used in the console
1310 to say that it has its own local value for the slot.
1311 The local flag bits are in the local_var_flags slot of the
1314 nuke_all_console_slots (&console_local_flags, make_int (-2));
1315 console_local_flags.defining_kbd_macro = always_local_resettable;
1316 console_local_flags.last_kbd_macro = always_local_resettable;
1317 console_local_flags.prefix_arg = always_local_resettable;
1318 console_local_flags.default_minibuffer_frame = always_local_resettable;
1319 console_local_flags.overriding_terminal_local_map =
1320 always_local_resettable;
1322 console_local_flags.tty_erase_char = always_local_resettable;
1325 console_local_flags.function_key_map = make_int (1);
1327 /* #### Warning, 0x4000000 (that's six zeroes) is the largest number
1328 currently allowable due to the XINT() handling of this value.
1329 With some rearrangement you can get 4 more bits. */
1334 #define CONSOLE_SLOTS_SIZE (offsetof (struct console, CONSOLE_SLOTS_LAST_NAME) - offsetof (struct console, CONSOLE_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
1335 #define CONSOLE_SLOTS_COUNT (CONSOLE_SLOTS_SIZE / sizeof (Lisp_Object))
1338 reinit_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 memcpy (&defs->CONSOLE_SLOTS_FIRST_NAME,
1347 console_defaults_saved_slots,
1348 CONSOLE_SLOTS_SIZE);
1349 memcpy (&syms->CONSOLE_SLOTS_FIRST_NAME,
1350 console_local_symbols_saved_slots,
1351 CONSOLE_SLOTS_SIZE);
1355 static const struct lrecord_description console_slots_description_1[] = {
1356 { XD_LISP_OBJECT_ARRAY, 0, CONSOLE_SLOTS_COUNT },
1360 static const struct struct_description console_slots_description = {
1362 console_slots_description_1
1366 complex_vars_of_console (void)
1368 struct console *defs, *syms;
1370 common_init_complex_vars_of_console ();
1372 defs = XCONSOLE (Vconsole_defaults);
1373 syms = XCONSOLE (Vconsole_local_symbols);
1374 console_defaults_saved_slots = &defs->CONSOLE_SLOTS_FIRST_NAME;
1375 console_local_symbols_saved_slots = &syms->CONSOLE_SLOTS_FIRST_NAME;
1376 dump_add_root_struct_ptr (&console_defaults_saved_slots, &console_slots_description);
1377 dump_add_root_struct_ptr (&console_local_symbols_saved_slots, &console_slots_description);
1379 DEFVAR_CONSOLE_DEFAULTS ("default-function-key-map", function_key_map /*
1380 Default value of `function-key-map' for consoles that don't override it.
1381 This is the same as (default-value 'function-key-map).
1384 DEFVAR_CONSOLE_LOCAL ("function-key-map", function_key_map /*
1385 Keymap mapping ASCII function key sequences onto their preferred forms.
1386 This allows Emacs to recognize function keys sent from ASCII
1387 terminals at any point in a key sequence.
1389 The `read-key-sequence' function replaces any subsequence bound by
1390 `function-key-map' with its binding. More precisely, when the active
1391 keymaps have no binding for the current key sequence but
1392 `function-key-map' binds a suffix of the sequence to a vector or string,
1393 `read-key-sequence' replaces the matching suffix with its binding, and
1394 continues with the new sequence. See `key-binding'.
1396 The events that come from bindings in `function-key-map' are not
1397 themselves looked up in `function-key-map'.
1399 For example, suppose `function-key-map' binds `ESC O P' to [f1].
1400 Typing `ESC O P' to `read-key-sequence' would return
1401 \[#<keypress-event f1>]. Typing `C-x ESC O P' would return
1402 \[#<keypress-event control-X> #<keypress-event f1>]. If [f1]
1403 were a prefix key, typing `ESC O P x' would return
1404 \[#<keypress-event f1> #<keypress-event x>].
1408 /* #### Should this somehow go to TTY data? How do we make it
1409 accessible from Lisp, then? */
1410 DEFVAR_CONSOLE_LOCAL ("tty-erase-char", tty_erase_char /*
1411 The ERASE character as set by the user with stty.
1412 When this value cannot be determined or would be meaningless (on non-TTY
1413 consoles, for example), it is set to nil.
1417 /* While this should be const it can't be because some things
1418 (i.e. edebug) do manipulate it. */
1419 DEFVAR_CONSOLE_LOCAL ("defining-kbd-macro", defining_kbd_macro /*
1420 Non-nil while a keyboard macro is being defined. Don't set this!
1423 DEFVAR_CONSOLE_LOCAL ("last-kbd-macro", last_kbd_macro /*
1424 Last keyboard macro defined, as a vector of events; nil if none defined.
1427 DEFVAR_CONSOLE_LOCAL ("prefix-arg", prefix_arg /*
1428 The value of the prefix argument for the next editing command.
1429 It may be a number, or the symbol `-' for just a minus sign as arg,
1430 or a list whose car is a number for just one or more C-U's
1431 or nil if no argument has been specified.
1433 You cannot examine this variable to find the argument for this command
1434 since it has been set to nil by the time you can look.
1435 Instead, you should use the variable `current-prefix-arg', although
1436 normally commands can get this prefix argument with (interactive "P").
1439 DEFVAR_CONSOLE_LOCAL ("default-minibuffer-frame",
1440 default_minibuffer_frame /*
1441 Minibufferless frames use this frame's minibuffer.
1443 Emacs cannot create minibufferless frames unless this is set to an
1444 appropriate surrogate.
1446 XEmacs consults this variable only when creating minibufferless
1447 frames; once the frame is created, it sticks with its assigned
1448 minibuffer, no matter what this variable is set to. This means that
1449 this variable doesn't necessarily say anything meaningful about the
1450 current set of frames, or where the minibuffer is currently being
1454 DEFVAR_CONSOLE_LOCAL ("overriding-terminal-local-map",
1455 overriding_terminal_local_map /*
1456 Keymap that overrides all other local keymaps, for the selected console only.
1457 If this variable is non-nil, it is used as a keymap instead of the
1458 buffer's local map, and the minor mode keymaps and text property keymaps.
1461 /* Check for DEFVAR_CONSOLE_LOCAL without initializing the corresponding
1462 slot of console_local_flags and vice-versa. Must be done after all
1463 DEFVAR_CONSOLE_LOCAL() calls. */
1464 #define MARKED_SLOT(slot) \
1465 if ((XINT (console_local_flags.slot) != -2 && \
1466 XINT (console_local_flags.slot) != -3) \
1467 != !(NILP (XCONSOLE (Vconsole_local_symbols)->slot))) \
1469 #include "conslots.h"