|
428
|
1 /* The console object.
|
|
|
2 Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
800
|
3 Copyright (C) 1996, 2002 Ben Wing.
|
|
428
|
4
|
|
|
5 This file is part of XEmacs.
|
|
|
6
|
|
|
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
|
|
|
10 later version.
|
|
|
11
|
|
|
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
|
|
|
15 for more details.
|
|
|
16
|
|
|
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. */
|
|
|
21
|
|
|
22 /* Synched up with: Not in FSF. */
|
|
|
23
|
|
853
|
24 /* Written by Ben Wing, late 1995?.
|
|
|
25 suspend-console, set-input-mode, and related stuff largely based on
|
|
|
26 existing code.
|
|
|
27 */
|
|
428
|
28
|
|
|
29 #include <config.h>
|
|
|
30 #include "lisp.h"
|
|
|
31
|
|
|
32 #include "buffer.h"
|
|
872
|
33 #include "console-impl.h"
|
|
|
34 #include "device-impl.h"
|
|
428
|
35 #include "events.h"
|
|
872
|
36 #include "frame-impl.h"
|
|
428
|
37 #include "redisplay.h"
|
|
|
38 #include "sysdep.h"
|
|
|
39 #include "window.h"
|
|
|
40
|
|
1204
|
41 #include "console-stream-impl.h"
|
|
872
|
42 #ifdef HAVE_TTY
|
|
|
43 #include "console-tty-impl.h"
|
|
|
44 #endif
|
|
800
|
45
|
|
2340
|
46 #ifdef HAVE_TTY
|
|
|
47 #define USED_IF_TTY(decl) decl
|
|
|
48 #else
|
|
|
49 #define USED_IF_TTY(decl) UNUSED (decl)
|
|
|
50 #endif
|
|
|
51
|
|
428
|
52 Lisp_Object Vconsole_list, Vselected_console;
|
|
|
53
|
|
|
54 Lisp_Object Vcreate_console_hook, Vdelete_console_hook;
|
|
|
55
|
|
|
56 Lisp_Object Qconsolep, Qconsole_live_p;
|
|
|
57 Lisp_Object Qcreate_console_hook;
|
|
|
58 Lisp_Object Qdelete_console_hook;
|
|
|
59
|
|
|
60 Lisp_Object Qsuspend_hook;
|
|
|
61 Lisp_Object Qsuspend_resume_hook;
|
|
|
62
|
|
|
63 /* This structure holds the default values of the console-local
|
|
|
64 variables defined with DEFVAR_CONSOLE_LOCAL, that have special
|
|
|
65 slots in each console. The default value occupies the same slot
|
|
|
66 in this structure as an individual console's value occupies in
|
|
|
67 that console. Setting the default value also goes through the
|
|
|
68 list of consoles and stores into each console that does not say
|
|
|
69 it has a local value. */
|
|
|
70 Lisp_Object Vconsole_defaults;
|
|
|
71 static void *console_defaults_saved_slots;
|
|
|
72
|
|
|
73 /* This structure marks which slots in a console have corresponding
|
|
|
74 default values in console_defaults.
|
|
|
75 Each such slot has a nonzero value in this structure.
|
|
|
76 The value has only one nonzero bit.
|
|
|
77
|
|
|
78 When a console has its own local value for a slot,
|
|
|
79 the bit for that slot (found in the same slot in this structure)
|
|
|
80 is turned on in the console's local_var_flags slot.
|
|
|
81
|
|
|
82 If a slot in this structure is 0, then there is a DEFVAR_CONSOLE_LOCAL
|
|
|
83 for the slot, but there is no default value for it; the corresponding
|
|
|
84 slot in console_defaults is not used except to initialize newly-created
|
|
|
85 consoles.
|
|
|
86
|
|
|
87 If a slot is -1, then there is a DEFVAR_CONSOLE_LOCAL for it
|
|
|
88 as well as a default value which is used to initialize newly-created
|
|
|
89 consoles and as a reset-value when local-vars are killed.
|
|
|
90
|
|
|
91 If a slot is -2, there is no DEFVAR_CONSOLE_LOCAL for it.
|
|
|
92 (The slot is always local, but there's no lisp variable for it.)
|
|
|
93 The default value is only used to initialize newly-creation consoles.
|
|
|
94
|
|
|
95 If a slot is -3, then there is no DEFVAR_CONSOLE_LOCAL for it but
|
|
|
96 there is a default which is used to initialize newly-creation
|
|
|
97 consoles and as a reset-value when local-vars are killed.
|
|
|
98
|
|
|
99
|
|
|
100 */
|
|
|
101 struct console console_local_flags;
|
|
|
102
|
|
|
103 /* This structure holds the names of symbols whose values may be
|
|
|
104 console-local. It is indexed and accessed in the same way as the above. */
|
|
|
105 static Lisp_Object Vconsole_local_symbols;
|
|
|
106 static void *console_local_symbols_saved_slots;
|
|
|
107
|
|
|
108 DEFINE_CONSOLE_TYPE (dead);
|
|
|
109
|
|
|
110 Lisp_Object Vconsole_type_list;
|
|
|
111
|
|
|
112 console_type_entry_dynarr *the_console_type_entry_dynarr;
|
|
|
113
|
|
|
114
|
|
934
|
115
|
|
1204
|
116 static const struct memory_description console_data_description_1 []= {
|
|
|
117 #ifdef HAVE_TTY
|
|
2551
|
118 { XD_BLOCK_PTR, tty_console, 1, { &tty_console_data_description} },
|
|
1204
|
119 #endif
|
|
2551
|
120 { XD_BLOCK_PTR, stream_console, 1, { &stream_console_data_description} },
|
|
934
|
121 { XD_END }
|
|
|
122 };
|
|
|
123
|
|
1204
|
124 static const struct sized_memory_description console_data_description = {
|
|
|
125 sizeof (void *), console_data_description_1
|
|
934
|
126 };
|
|
|
127
|
|
1204
|
128 static const struct memory_description console_description [] = {
|
|
934
|
129 { XD_INT, offsetof (struct console, contype) },
|
|
1204
|
130 #define MARKED_SLOT(x) { XD_LISP_OBJECT, offsetof (struct console, x) },
|
|
|
131 #include "conslots.h"
|
|
2367
|
132 { XD_BLOCK_PTR, offsetof (struct console, conmeths), 1,
|
|
2551
|
133 { &console_methods_description } },
|
|
934
|
134 { XD_UNION, offsetof (struct console, console_data),
|
|
2551
|
135 XD_INDIRECT (0, 0), { &console_data_description } },
|
|
934
|
136 { XD_END }
|
|
|
137 };
|
|
|
138
|
|
428
|
139 static Lisp_Object
|
|
|
140 mark_console (Lisp_Object obj)
|
|
|
141 {
|
|
|
142 struct console *con = XCONSOLE (obj);
|
|
|
143
|
|
1204
|
144 #define MARKED_SLOT(x) mark_object (con->x);
|
|
428
|
145 #include "conslots.h"
|
|
|
146
|
|
|
147 /* Can be zero for Vconsole_defaults, Vconsole_local_symbols */
|
|
|
148 if (con->conmeths)
|
|
|
149 {
|
|
|
150 mark_object (con->conmeths->symbol);
|
|
|
151 MAYBE_CONMETH (con, mark_console, (con));
|
|
|
152 }
|
|
|
153
|
|
|
154 return Qnil;
|
|
|
155 }
|
|
|
156
|
|
|
157 static void
|
|
2286
|
158 print_console (Lisp_Object obj, Lisp_Object printcharfun,
|
|
|
159 int UNUSED (escapeflag))
|
|
428
|
160 {
|
|
|
161 struct console *con = XCONSOLE (obj);
|
|
|
162
|
|
|
163 if (print_readably)
|
|
563
|
164 printing_unreadable_object ("#<console %s 0x%x>",
|
|
|
165 XSTRING_DATA (con->name), con->header.uid);
|
|
428
|
166
|
|
800
|
167 write_fmt_string (printcharfun, "#<%s-console",
|
|
|
168 !CONSOLE_LIVE_P (con) ? "dead" : CONSOLE_TYPE_NAME (con));
|
|
440
|
169 if (CONSOLE_LIVE_P (con) && !NILP (CONSOLE_CONNECTION (con)))
|
|
800
|
170 write_fmt_string_lisp (printcharfun, " on %S", 1,
|
|
|
171 CONSOLE_CONNECTION (con));
|
|
|
172 write_fmt_string (printcharfun, " 0x%x>", con->header.uid);
|
|
428
|
173 }
|
|
|
174
|
|
934
|
175 DEFINE_LRECORD_IMPLEMENTATION ("console", console,
|
|
|
176 0, /*dumpable-flag*/
|
|
|
177 mark_console, print_console, 0, 0, 0,
|
|
|
178 console_description,
|
|
|
179 struct console);
|
|
428
|
180
|
|
1204
|
181
|
|
|
182 static void
|
|
|
183 set_quit_events (struct console *con, Lisp_Object key)
|
|
|
184 {
|
|
|
185 /* Make sure to run Fcharacter_to_event() *BEFORE* setting QUIT_CHAR,
|
|
|
186 so that nothing is changed when invalid values trigger an error! */
|
|
|
187 con->quit_event = Fcharacter_to_event (key, Qnil, wrap_console (con), Qnil);
|
|
|
188 con->quit_char = key;
|
|
|
189 con->critical_quit_event = Fcopy_event (con->quit_event, Qnil);
|
|
|
190 upshift_event (con->critical_quit_event);
|
|
|
191 }
|
|
|
192
|
|
428
|
193 static struct console *
|
|
1204
|
194 allocate_console (Lisp_Object type)
|
|
428
|
195 {
|
|
|
196 Lisp_Object console;
|
|
2720
|
197 #ifdef MC_ALLOC
|
|
|
198 struct console *con = alloc_lrecord_type (struct console, &lrecord_console);
|
|
|
199 #else /* not MC_ALLOC */
|
|
428
|
200 struct console *con = alloc_lcrecord_type (struct console, &lrecord_console);
|
|
2720
|
201 #endif /* not MC_ALLOC */
|
|
428
|
202 struct gcpro gcpro1;
|
|
|
203
|
|
2720
|
204 #ifdef MC_ALLOC
|
|
|
205 copy_lrecord (con, XCONSOLE (Vconsole_defaults));
|
|
|
206 #else /* not MC_ALLOC */
|
|
428
|
207 copy_lcrecord (con, XCONSOLE (Vconsole_defaults));
|
|
2720
|
208 #endif /* not MC_ALLOC */
|
|
428
|
209
|
|
793
|
210 console = wrap_console (con);
|
|
428
|
211 GCPRO1 (console);
|
|
|
212
|
|
1204
|
213 con->conmeths = decode_console_type (type, ERROR_ME);
|
|
|
214 con->contype = get_console_variant (type);
|
|
771
|
215 con->command_builder = allocate_command_builder (console, 1);
|
|
428
|
216 con->function_key_map = Fmake_sparse_keymap (Qnil);
|
|
1204
|
217 set_quit_events (con, make_char (7)); /* C-g */
|
|
428
|
218
|
|
|
219 UNGCPRO;
|
|
|
220 return con;
|
|
|
221 }
|
|
|
222
|
|
|
223 struct console *
|
|
|
224 decode_console (Lisp_Object console)
|
|
|
225 {
|
|
|
226 if (NILP (console))
|
|
|
227 console = Fselected_console ();
|
|
|
228 /* quietly accept devices and frames for the console arg */
|
|
|
229 if (DEVICEP (console) || FRAMEP (console))
|
|
|
230 console = DEVICE_CONSOLE (decode_device (console));
|
|
|
231 CHECK_LIVE_CONSOLE (console);
|
|
|
232 return XCONSOLE (console);
|
|
|
233 }
|
|
|
234
|
|
|
235
|
|
|
236 struct console_methods *
|
|
578
|
237 decode_console_type (Lisp_Object type, Error_Behavior errb)
|
|
428
|
238 {
|
|
|
239 int i;
|
|
|
240
|
|
|
241 for (i = 0; i < Dynarr_length (the_console_type_entry_dynarr); i++)
|
|
|
242 if (EQ (type, Dynarr_at (the_console_type_entry_dynarr, i).symbol))
|
|
|
243 return Dynarr_at (the_console_type_entry_dynarr, i).meths;
|
|
|
244
|
|
563
|
245 maybe_invalid_constant ("Invalid console type", type, Qconsole, errb);
|
|
428
|
246
|
|
|
247 return 0;
|
|
|
248 }
|
|
|
249
|
|
934
|
250 enum console_variant
|
|
|
251 get_console_variant (Lisp_Object type)
|
|
|
252 {
|
|
|
253 if (EQ (type, Qtty))
|
|
1204
|
254 return tty_console;
|
|
934
|
255
|
|
|
256 if (EQ (type, Qgtk))
|
|
1204
|
257 return gtk_console;
|
|
934
|
258
|
|
|
259 if (EQ (type, Qx))
|
|
1204
|
260 return x_console;
|
|
934
|
261
|
|
|
262 if (EQ (type, Qmswindows))
|
|
1204
|
263 return mswindows_console;
|
|
934
|
264
|
|
1346
|
265 if (EQ (type, Qmsprinter))
|
|
|
266 return msprinter_console;
|
|
|
267
|
|
934
|
268 if (EQ (type, Qstream))
|
|
1204
|
269 return stream_console;
|
|
934
|
270
|
|
2500
|
271 ABORT (); /* should never happen */
|
|
934
|
272 return dead_console;
|
|
|
273 }
|
|
|
274
|
|
428
|
275 int
|
|
|
276 valid_console_type_p (Lisp_Object type)
|
|
|
277 {
|
|
|
278 return decode_console_type (type, ERROR_ME_NOT) != 0;
|
|
|
279 }
|
|
|
280
|
|
|
281 DEFUN ("valid-console-type-p", Fvalid_console_type_p, 1, 1, 0, /*
|
|
444
|
282 Return t if CONSOLE-TYPE is a valid console type.
|
|
1346
|
283 Valid types are 'x, 'tty, 'mswindows, 'msprinter, 'gtk, and 'stream.
|
|
428
|
284 */
|
|
|
285 (console_type))
|
|
|
286 {
|
|
|
287 return valid_console_type_p (console_type) ? Qt : Qnil;
|
|
|
288 }
|
|
|
289
|
|
|
290 DEFUN ("console-type-list", Fconsole_type_list, 0, 0, 0, /*
|
|
|
291 Return a list of valid console types.
|
|
|
292 */
|
|
|
293 ())
|
|
|
294 {
|
|
|
295 return Fcopy_sequence (Vconsole_type_list);
|
|
|
296 }
|
|
|
297
|
|
|
298 DEFUN ("cdfw-console", Fcdfw_console, 1, 1, 0, /*
|
|
|
299 Given a console, device, frame, or window, return the associated console.
|
|
|
300 Return nil otherwise.
|
|
|
301 */
|
|
444
|
302 (object))
|
|
428
|
303 {
|
|
444
|
304 return CDFW_CONSOLE (object);
|
|
428
|
305 }
|
|
|
306
|
|
872
|
307 int
|
|
|
308 console_live_p (struct console *c)
|
|
|
309 {
|
|
|
310 return CONSOLE_LIVE_P (c);
|
|
|
311 }
|
|
|
312
|
|
|
313 Lisp_Object
|
|
|
314 console_device_list (struct console *c)
|
|
|
315 {
|
|
|
316 return CONSOLE_DEVICE_LIST (c);
|
|
|
317 }
|
|
|
318
|
|
428
|
319
|
|
|
320 DEFUN ("selected-console", Fselected_console, 0, 0, 0, /*
|
|
|
321 Return the console which is currently active.
|
|
|
322 */
|
|
|
323 ())
|
|
|
324 {
|
|
|
325 return Vselected_console;
|
|
|
326 }
|
|
|
327
|
|
|
328 /* Called from selected_device_1(), called from selected_frame_1(),
|
|
|
329 called from Fselect_window() */
|
|
|
330 void
|
|
|
331 select_console_1 (Lisp_Object console)
|
|
|
332 {
|
|
|
333 /* perhaps this should do something more complicated */
|
|
|
334 Vselected_console = console;
|
|
|
335
|
|
|
336 /* #### Schedule this to be removed in 19.14 */
|
|
|
337 #ifdef HAVE_X_WINDOWS
|
|
|
338 if (CONSOLE_X_P (XCONSOLE (console)))
|
|
|
339 Vwindow_system = Qx;
|
|
|
340 else
|
|
|
341 #endif
|
|
462
|
342 #ifdef HAVE_GTK
|
|
|
343 if (CONSOLE_GTK_P (XCONSOLE (console)))
|
|
|
344 Vwindow_system = Qgtk;
|
|
|
345 else
|
|
|
346 #endif
|
|
428
|
347 #ifdef HAVE_MS_WINDOWS
|
|
|
348 if (CONSOLE_MSWINDOWS_P (XCONSOLE (console)))
|
|
|
349 Vwindow_system = Qmswindows;
|
|
|
350 else
|
|
|
351 #endif
|
|
|
352 Vwindow_system = Qnil;
|
|
|
353 }
|
|
|
354
|
|
|
355 DEFUN ("select-console", Fselect_console, 1, 1, 0, /*
|
|
|
356 Select the console CONSOLE.
|
|
|
357 Subsequent editing commands apply to its selected device, selected frame,
|
|
|
358 and selected window. The selection of CONSOLE lasts until the next time
|
|
|
359 the user does something to select a different console, or until the next
|
|
|
360 time this function is called.
|
|
|
361 */
|
|
|
362 (console))
|
|
|
363 {
|
|
|
364 Lisp_Object device;
|
|
|
365
|
|
|
366 CHECK_LIVE_CONSOLE (console);
|
|
|
367
|
|
|
368 device = CONSOLE_SELECTED_DEVICE (XCONSOLE (console));
|
|
|
369 if (!NILP (device))
|
|
|
370 {
|
|
|
371 struct device *d = XDEVICE (device);
|
|
|
372 Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
|
|
|
373 if (!NILP (frame))
|
|
|
374 {
|
|
|
375 struct frame *f = XFRAME(frame);
|
|
|
376 Fselect_window (FRAME_SELECTED_WINDOW (f), Qnil);
|
|
|
377 }
|
|
|
378 else
|
|
563
|
379 invalid_operation ("Can't select console with no frames", Qunbound);
|
|
428
|
380 }
|
|
|
381 else
|
|
563
|
382 invalid_operation ("Can't select a console with no devices", Qunbound);
|
|
428
|
383 return Qnil;
|
|
|
384 }
|
|
|
385
|
|
|
386 void
|
|
|
387 set_console_last_nonminibuf_frame (struct console *con,
|
|
|
388 Lisp_Object frame)
|
|
|
389 {
|
|
|
390 con->last_nonminibuf_frame = frame;
|
|
|
391 }
|
|
|
392
|
|
|
393 DEFUN ("consolep", Fconsolep, 1, 1, 0, /*
|
|
|
394 Return non-nil if OBJECT is a console.
|
|
|
395 */
|
|
|
396 (object))
|
|
|
397 {
|
|
|
398 return CONSOLEP (object) ? Qt : Qnil;
|
|
|
399 }
|
|
|
400
|
|
|
401 DEFUN ("console-live-p", Fconsole_live_p, 1, 1, 0, /*
|
|
|
402 Return non-nil if OBJECT is a console that has not been deleted.
|
|
|
403 */
|
|
|
404 (object))
|
|
|
405 {
|
|
|
406 return CONSOLEP (object) && CONSOLE_LIVE_P (XCONSOLE (object)) ? Qt : Qnil;
|
|
|
407 }
|
|
|
408
|
|
|
409 DEFUN ("console-type", Fconsole_type, 0, 1, 0, /*
|
|
444
|
410 Return the console type (e.g. `x' or `tty') of CONSOLE.
|
|
1346
|
411 Value is
|
|
|
412 `tty' for a tty console (a character-only terminal),
|
|
428
|
413 `x' for a console that is an X display,
|
|
1346
|
414 `mswindows' for a console that is an MS Windows connection,
|
|
|
415 `msprinter' for a console that is an MS Windows printer connection,
|
|
|
416 `gtk' for a console that is a GTK connection,
|
|
428
|
417 `stream' for a stream console (which acts like a stdio stream), and
|
|
|
418 `dead' for a deleted console.
|
|
|
419 */
|
|
|
420 (console))
|
|
|
421 {
|
|
|
422 /* don't call decode_console() because we want to allow for dead
|
|
|
423 consoles. */
|
|
|
424 if (NILP (console))
|
|
|
425 console = Fselected_console ();
|
|
|
426 CHECK_CONSOLE (console);
|
|
|
427 return CONSOLE_TYPE (XCONSOLE (console));
|
|
|
428 }
|
|
|
429
|
|
|
430 DEFUN ("console-name", Fconsole_name, 0, 1, 0, /*
|
|
444
|
431 Return the name of CONSOLE.
|
|
428
|
432 */
|
|
|
433 (console))
|
|
|
434 {
|
|
|
435 return CONSOLE_NAME (decode_console (console));
|
|
|
436 }
|
|
|
437
|
|
|
438 DEFUN ("console-connection", Fconsole_connection, 0, 1, 0, /*
|
|
|
439 Return the connection of the specified console.
|
|
|
440 CONSOLE defaults to the selected console if omitted.
|
|
|
441 */
|
|
|
442 (console))
|
|
|
443 {
|
|
|
444 return CONSOLE_CONNECTION (decode_console (console));
|
|
|
445 }
|
|
|
446
|
|
|
447 static Lisp_Object
|
|
|
448 semi_canonicalize_console_connection (struct console_methods *meths,
|
|
578
|
449 Lisp_Object name, Error_Behavior errb)
|
|
428
|
450 {
|
|
440
|
451 if (HAS_CONTYPE_METH_P (meths, semi_canonicalize_console_connection))
|
|
|
452 return CONTYPE_METH (meths, semi_canonicalize_console_connection,
|
|
|
453 (name, errb));
|
|
|
454 else
|
|
|
455 return CONTYPE_METH_OR_GIVEN (meths, canonicalize_console_connection,
|
|
|
456 (name, errb), name);
|
|
428
|
457 }
|
|
|
458
|
|
|
459 static Lisp_Object
|
|
|
460 canonicalize_console_connection (struct console_methods *meths,
|
|
578
|
461 Lisp_Object name, Error_Behavior errb)
|
|
428
|
462 {
|
|
440
|
463 if (HAS_CONTYPE_METH_P (meths, canonicalize_console_connection))
|
|
|
464 return CONTYPE_METH (meths, canonicalize_console_connection,
|
|
|
465 (name, errb));
|
|
|
466 else
|
|
|
467 return CONTYPE_METH_OR_GIVEN (meths, semi_canonicalize_console_connection,
|
|
|
468 (name, errb), name);
|
|
428
|
469 }
|
|
|
470
|
|
|
471 static Lisp_Object
|
|
|
472 find_console_of_type (struct console_methods *meths, Lisp_Object canon)
|
|
|
473 {
|
|
|
474 Lisp_Object concons;
|
|
|
475
|
|
|
476 CONSOLE_LOOP (concons)
|
|
|
477 {
|
|
|
478 Lisp_Object console = XCAR (concons);
|
|
|
479
|
|
|
480 if (EQ (CONMETH_TYPE (meths), CONSOLE_TYPE (XCONSOLE (console)))
|
|
|
481 && internal_equal (CONSOLE_CANON_CONNECTION (XCONSOLE (console)),
|
|
|
482 canon, 0))
|
|
|
483 return console;
|
|
|
484 }
|
|
|
485
|
|
|
486 return Qnil;
|
|
|
487 }
|
|
|
488
|
|
|
489 DEFUN ("find-console", Ffind_console, 1, 2, 0, /*
|
|
|
490 Look for an existing console attached to connection CONNECTION.
|
|
|
491 Return the console if found; otherwise, return nil.
|
|
|
492
|
|
|
493 If TYPE is specified, only return consoles of that type; otherwise,
|
|
|
494 return consoles of any type. (It is possible, although unlikely,
|
|
|
495 that two consoles of different types could have the same connection
|
|
|
496 name; in such a case, the first console found is returned.)
|
|
|
497 */
|
|
|
498 (connection, type))
|
|
|
499 {
|
|
|
500 Lisp_Object canon = Qnil;
|
|
|
501 struct gcpro gcpro1;
|
|
|
502
|
|
|
503 GCPRO1 (canon);
|
|
|
504
|
|
|
505 if (!NILP (type))
|
|
|
506 {
|
|
|
507 struct console_methods *conmeths = decode_console_type (type, ERROR_ME);
|
|
|
508 canon = canonicalize_console_connection (conmeths, connection,
|
|
|
509 ERROR_ME_NOT);
|
|
|
510 if (UNBOUNDP (canon))
|
|
|
511 RETURN_UNGCPRO (Qnil);
|
|
|
512
|
|
|
513 RETURN_UNGCPRO (find_console_of_type (conmeths, canon));
|
|
|
514 }
|
|
|
515 else
|
|
|
516 {
|
|
|
517 int i;
|
|
|
518
|
|
|
519 for (i = 0; i < Dynarr_length (the_console_type_entry_dynarr); i++)
|
|
|
520 {
|
|
|
521 struct console_methods *conmeths =
|
|
|
522 Dynarr_at (the_console_type_entry_dynarr, i).meths;
|
|
|
523 canon = canonicalize_console_connection (conmeths, connection,
|
|
|
524 ERROR_ME_NOT);
|
|
|
525 if (!UNBOUNDP (canon))
|
|
|
526 {
|
|
|
527 Lisp_Object console = find_console_of_type (conmeths, canon);
|
|
|
528 if (!NILP (console))
|
|
|
529 RETURN_UNGCPRO (console);
|
|
|
530 }
|
|
|
531 }
|
|
|
532
|
|
|
533 RETURN_UNGCPRO (Qnil);
|
|
|
534 }
|
|
|
535 }
|
|
|
536
|
|
|
537 DEFUN ("get-console", Fget_console, 1, 2, 0, /*
|
|
|
538 Look for an existing console attached to connection CONNECTION.
|
|
|
539 Return the console if found; otherwise, signal an error.
|
|
|
540
|
|
|
541 If TYPE is specified, only return consoles of that type; otherwise,
|
|
|
542 return consoles of any type. (It is possible, although unlikely,
|
|
|
543 that two consoles of different types could have the same connection
|
|
|
544 name; in such a case, the first console found is returned.)
|
|
|
545 */
|
|
|
546 (connection, type))
|
|
|
547 {
|
|
|
548 Lisp_Object console = Ffind_console (connection, type);
|
|
|
549 if (NILP (console))
|
|
|
550 {
|
|
|
551 if (NILP (type))
|
|
563
|
552 invalid_argument ("No such console", connection);
|
|
428
|
553 else
|
|
563
|
554 invalid_argument_2 ("No such console", type, connection);
|
|
428
|
555 }
|
|
|
556 return console;
|
|
|
557 }
|
|
|
558
|
|
|
559 Lisp_Object
|
|
|
560 create_console (Lisp_Object name, Lisp_Object type, Lisp_Object connection,
|
|
|
561 Lisp_Object props)
|
|
|
562 {
|
|
|
563 /* This function can GC */
|
|
|
564 struct console *con;
|
|
|
565 Lisp_Object console;
|
|
|
566 struct gcpro gcpro1;
|
|
|
567
|
|
|
568 console = Ffind_console (connection, type);
|
|
|
569 if (!NILP (console))
|
|
|
570 return console;
|
|
|
571
|
|
1204
|
572 con = allocate_console (type);
|
|
793
|
573 console = wrap_console (con);
|
|
428
|
574
|
|
|
575 GCPRO1 (console);
|
|
|
576
|
|
|
577 CONSOLE_NAME (con) = name;
|
|
|
578 CONSOLE_CONNECTION (con) =
|
|
|
579 semi_canonicalize_console_connection (con->conmeths, connection,
|
|
|
580 ERROR_ME);
|
|
|
581 CONSOLE_CANON_CONNECTION (con) =
|
|
|
582 canonicalize_console_connection (con->conmeths, connection,
|
|
|
583 ERROR_ME);
|
|
|
584
|
|
|
585 MAYBE_CONMETH (con, init_console, (con, props));
|
|
|
586
|
|
|
587 /* Do it this way so that the console list is in order of creation */
|
|
|
588 Vconsole_list = nconc2 (Vconsole_list, Fcons (console, Qnil));
|
|
853
|
589 note_object_created (console);
|
|
428
|
590
|
|
440
|
591 if (CONMETH_OR_GIVEN (con, initially_selected_for_input, (con), 0))
|
|
428
|
592 event_stream_select_console (con);
|
|
|
593
|
|
|
594 UNGCPRO;
|
|
|
595 return console;
|
|
|
596 }
|
|
|
597
|
|
|
598 void
|
|
|
599 add_entry_to_console_type_list (Lisp_Object symbol,
|
|
|
600 struct console_methods *meths)
|
|
|
601 {
|
|
|
602 struct console_type_entry entry;
|
|
|
603
|
|
|
604 entry.symbol = symbol;
|
|
|
605 entry.meths = meths;
|
|
|
606 Dynarr_add (the_console_type_entry_dynarr, entry);
|
|
|
607 Vconsole_type_list = Fcons (symbol, Vconsole_type_list);
|
|
|
608 }
|
|
|
609
|
|
|
610 /* find a console other than the selected one. Prefer non-stream
|
|
|
611 consoles over stream consoles. */
|
|
|
612
|
|
|
613 static Lisp_Object
|
|
|
614 find_other_console (Lisp_Object console)
|
|
|
615 {
|
|
|
616 Lisp_Object concons;
|
|
|
617
|
|
|
618 /* look for a non-stream console */
|
|
|
619 CONSOLE_LOOP (concons)
|
|
|
620 {
|
|
|
621 Lisp_Object con = XCAR (concons);
|
|
|
622 if (!CONSOLE_STREAM_P (XCONSOLE (con))
|
|
|
623 && !EQ (con, console)
|
|
|
624 && !NILP (CONSOLE_SELECTED_DEVICE (XCONSOLE (con)))
|
|
|
625 && !NILP (DEVICE_SELECTED_FRAME
|
|
|
626 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (con))))))
|
|
|
627 break;
|
|
|
628 }
|
|
|
629 if (!NILP (concons))
|
|
|
630 return XCAR (concons);
|
|
|
631
|
|
|
632 /* OK, now look for a stream console */
|
|
|
633 CONSOLE_LOOP (concons)
|
|
|
634 {
|
|
|
635 Lisp_Object con = XCAR (concons);
|
|
|
636 if (!EQ (con, console)
|
|
|
637 && !NILP (CONSOLE_SELECTED_DEVICE (XCONSOLE (con)))
|
|
|
638 && !NILP (DEVICE_SELECTED_FRAME
|
|
|
639 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (con))))))
|
|
|
640 break;
|
|
|
641 }
|
|
|
642 if (!NILP (concons))
|
|
|
643 return XCAR (concons);
|
|
|
644
|
|
|
645 /* Sorry, there ain't none */
|
|
|
646 return Qnil;
|
|
|
647 }
|
|
|
648
|
|
|
649 static int
|
|
|
650 find_nonminibuffer_frame_not_on_console_predicate (Lisp_Object frame,
|
|
|
651 void *closure)
|
|
|
652 {
|
|
|
653 Lisp_Object console;
|
|
|
654
|
|
826
|
655 console = VOID_TO_LISP (closure);
|
|
428
|
656 if (FRAME_MINIBUF_ONLY_P (XFRAME (frame)))
|
|
|
657 return 0;
|
|
|
658 if (EQ (console, FRAME_CONSOLE (XFRAME (frame))))
|
|
|
659 return 0;
|
|
|
660 return 1;
|
|
|
661 }
|
|
|
662
|
|
|
663 static Lisp_Object
|
|
|
664 find_nonminibuffer_frame_not_on_console (Lisp_Object console)
|
|
|
665 {
|
|
|
666 return find_some_frame (find_nonminibuffer_frame_not_on_console_predicate,
|
|
|
667 LISP_TO_VOID (console));
|
|
|
668 }
|
|
|
669
|
|
617
|
670 static void
|
|
|
671 nuke_all_console_slots (struct console *con, Lisp_Object zap)
|
|
|
672 {
|
|
2720
|
673 #ifdef MC_ALLOC
|
|
|
674 zero_lrecord (con);
|
|
|
675 #else /* not MC_ALLOC */
|
|
617
|
676 zero_lcrecord (con);
|
|
2720
|
677 #endif /* not MC_ALLOC */
|
|
617
|
678
|
|
1204
|
679 #define MARKED_SLOT(x) con->x = zap;
|
|
617
|
680 #include "conslots.h"
|
|
|
681 }
|
|
|
682
|
|
428
|
683 /* Delete console CON.
|
|
|
684
|
|
|
685 If FORCE is non-zero, allow deletion of the only frame.
|
|
|
686
|
|
|
687 If CALLED_FROM_KILL_EMACS is non-zero, then, if
|
|
|
688 deleting the last console, just delete it,
|
|
|
689 instead of calling `save-buffers-kill-emacs'.
|
|
|
690
|
|
|
691 If FROM_IO_ERROR is non-zero, then the console is gone due
|
|
|
692 to an I/O error. This affects what happens if we exit
|
|
|
693 (we do an emergency exit instead of `save-buffers-kill-emacs'.)
|
|
|
694 */
|
|
|
695
|
|
|
696 void
|
|
|
697 delete_console_internal (struct console *con, int force,
|
|
|
698 int called_from_kill_emacs, int from_io_error)
|
|
|
699 {
|
|
|
700 /* This function can GC */
|
|
|
701 Lisp_Object console;
|
|
|
702 struct gcpro gcpro1;
|
|
|
703
|
|
|
704 /* OK to delete an already-deleted console. */
|
|
|
705 if (!CONSOLE_LIVE_P (con))
|
|
|
706 return;
|
|
|
707
|
|
793
|
708 console = wrap_console (con);
|
|
853
|
709
|
|
|
710 if (!force)
|
|
|
711 check_allowed_operation (OPERATION_DELETE_OBJECT, console, Qnil);
|
|
|
712
|
|
428
|
713 GCPRO1 (console);
|
|
|
714
|
|
|
715 if (!called_from_kill_emacs)
|
|
|
716 {
|
|
|
717 int down_we_go = 0;
|
|
|
718
|
|
|
719 if ((XINT (Flength (Vconsole_list)) == 1)
|
|
|
720 /* if we just created the console, it might not be listed,
|
|
|
721 or something ... */
|
|
|
722 && !NILP (memq_no_quit (console, Vconsole_list)))
|
|
|
723 down_we_go = 1;
|
|
|
724 /* If there aren't any nonminibuffer frames that would
|
|
|
725 be left, then exit. */
|
|
|
726 else if (NILP (find_nonminibuffer_frame_not_on_console (console)))
|
|
|
727 down_we_go = 1;
|
|
|
728
|
|
|
729 if (down_we_go)
|
|
|
730 {
|
|
|
731 if (!force)
|
|
563
|
732 invalid_operation ("Attempt to delete the only frame", Qunbound);
|
|
428
|
733 else if (from_io_error)
|
|
|
734 {
|
|
|
735 /* Mayday mayday! We're going down! */
|
|
|
736 stderr_out (" Autosaving and exiting...\n");
|
|
|
737 Vwindow_system = Qnil; /* let it lie! */
|
|
|
738 preparing_for_armageddon = 1;
|
|
|
739 Fkill_emacs (make_int (70));
|
|
|
740 }
|
|
|
741 else
|
|
|
742 {
|
|
|
743 call0 (Qsave_buffers_kill_emacs);
|
|
|
744 UNGCPRO;
|
|
|
745 /* If we get here, the user said they didn't want
|
|
|
746 to exit, so don't. */
|
|
|
747 return;
|
|
|
748 }
|
|
|
749 }
|
|
|
750 }
|
|
|
751
|
|
|
752 /* Breathe a sigh of relief. We're still alive. */
|
|
|
753
|
|
|
754 {
|
|
|
755 Lisp_Object frmcons, devcons;
|
|
|
756
|
|
|
757 /* First delete all frames without their own minibuffers,
|
|
|
758 to avoid errors coming from attempting to delete a frame
|
|
|
759 that is a surrogate for another frame.
|
|
|
760
|
|
|
761 We don't set "called_from_delete_console" because we want the
|
|
|
762 device to go ahead and get deleted if we delete the last frame
|
|
|
763 on a device. We won't run into trouble here because for any
|
|
|
764 frame without a minibuffer, there has to be another one on
|
|
|
765 the same console with a minibuffer, and we're not deleting that,
|
|
|
766 so delete_console_internal() won't get recursively called.
|
|
|
767
|
|
|
768 WRONG! With surrogate minibuffers this isn't true. Frames
|
|
|
769 with only a minibuffer are not enough to prevent
|
|
|
770 delete_frame_internal from triggering a device deletion. */
|
|
|
771 CONSOLE_FRAME_LOOP_NO_BREAK (frmcons, devcons, con)
|
|
|
772 {
|
|
|
773 struct frame *f = XFRAME (XCAR (frmcons));
|
|
|
774 /* delete_frame_internal() might do anything such as run hooks,
|
|
|
775 so be defensive. */
|
|
|
776 if (FRAME_LIVE_P (f) && !FRAME_HAS_MINIBUF_P (f))
|
|
|
777 delete_frame_internal (f, 1, 1, from_io_error);
|
|
|
778
|
|
|
779 if (!CONSOLE_LIVE_P (con)) /* make sure the delete-*-hook didn't
|
|
|
780 go ahead and delete anything */
|
|
|
781 {
|
|
|
782 UNGCPRO;
|
|
|
783 return;
|
|
|
784 }
|
|
|
785 }
|
|
|
786
|
|
|
787 CONSOLE_DEVICE_LOOP (devcons, con)
|
|
|
788 {
|
|
|
789 struct device *d = XDEVICE (XCAR (devcons));
|
|
|
790 /* delete_device_internal() might do anything such as run hooks,
|
|
|
791 so be defensive. */
|
|
|
792 if (DEVICE_LIVE_P (d))
|
|
|
793 delete_device_internal (d, 1, 1, from_io_error);
|
|
|
794 if (!CONSOLE_LIVE_P (con)) /* make sure the delete-*-hook didn't
|
|
|
795 go ahead and delete anything */
|
|
|
796 {
|
|
|
797 UNGCPRO;
|
|
|
798 return;
|
|
|
799 }
|
|
|
800 }
|
|
|
801 }
|
|
|
802
|
|
|
803 CONSOLE_SELECTED_DEVICE (con) = Qnil;
|
|
|
804
|
|
|
805 /* try to select another console */
|
|
|
806
|
|
|
807 if (EQ (console, Fselected_console ()))
|
|
|
808 {
|
|
|
809 Lisp_Object other_dev = find_other_console (console);
|
|
|
810 if (!NILP (other_dev))
|
|
|
811 Fselect_console (other_dev);
|
|
|
812 else
|
|
|
813 {
|
|
|
814 /* necessary? */
|
|
|
815 Vselected_console = Qnil;
|
|
|
816 Vwindow_system = Qnil;
|
|
|
817 }
|
|
|
818 }
|
|
|
819
|
|
|
820 if (con->input_enabled)
|
|
|
821 event_stream_unselect_console (con);
|
|
|
822
|
|
|
823 MAYBE_CONMETH (con, delete_console, (con));
|
|
|
824
|
|
|
825 Vconsole_list = delq_no_quit (console, Vconsole_list);
|
|
617
|
826
|
|
428
|
827 RESET_CHANGED_SET_FLAGS;
|
|
617
|
828
|
|
|
829 /* Nobody should be accessing anything in this object any more, and
|
|
|
830 making all Lisp_Objects Qnil allows for better GC'ing in case a
|
|
|
831 pointer to the dead console continues to hang around. Zero all
|
|
|
832 other structs in case someone tries to access something through
|
|
|
833 them. */
|
|
|
834 nuke_all_console_slots (con, Qnil);
|
|
428
|
835 con->conmeths = dead_console_methods;
|
|
1204
|
836 con->contype = dead_console;
|
|
853
|
837 note_object_deleted (console);
|
|
428
|
838
|
|
|
839 UNGCPRO;
|
|
|
840 }
|
|
|
841
|
|
|
842 void
|
|
|
843 io_error_delete_console (Lisp_Object console)
|
|
|
844 {
|
|
|
845 delete_console_internal (XCONSOLE (console), 1, 0, 1);
|
|
|
846 }
|
|
|
847
|
|
|
848 DEFUN ("delete-console", Fdelete_console, 1, 2, 0, /*
|
|
|
849 Delete CONSOLE, permanently eliminating it from use.
|
|
|
850 Normally, you cannot delete the last non-minibuffer-only frame (you must
|
|
|
851 use `save-buffers-kill-emacs' or `kill-emacs'). However, if optional
|
|
|
852 second argument FORCE is non-nil, you can delete the last frame. (This
|
|
|
853 will automatically call `save-buffers-kill-emacs'.)
|
|
|
854 */
|
|
|
855 (console, force))
|
|
|
856 {
|
|
|
857 CHECK_CONSOLE (console);
|
|
|
858 delete_console_internal (XCONSOLE (console), !NILP (force), 0, 0);
|
|
|
859 return Qnil;
|
|
|
860 }
|
|
|
861
|
|
|
862 DEFUN ("console-list", Fconsole_list, 0, 0, 0, /*
|
|
|
863 Return a list of all consoles.
|
|
|
864 */
|
|
|
865 ())
|
|
|
866 {
|
|
|
867 return Fcopy_sequence (Vconsole_list);
|
|
|
868 }
|
|
|
869
|
|
|
870 DEFUN ("console-device-list", Fconsole_device_list, 0, 1, 0, /*
|
|
|
871 Return a list of all devices on CONSOLE.
|
|
444
|
872 If CONSOLE is nil, the selected console is used.
|
|
428
|
873 */
|
|
|
874 (console))
|
|
|
875 {
|
|
|
876 return Fcopy_sequence (CONSOLE_DEVICE_LIST (decode_console (console)));
|
|
|
877 }
|
|
|
878
|
|
|
879 DEFUN ("console-enable-input", Fconsole_enable_input, 1, 1, 0, /*
|
|
|
880 Enable input on console CONSOLE.
|
|
|
881 */
|
|
|
882 (console))
|
|
|
883 {
|
|
|
884 struct console *con = decode_console (console);
|
|
|
885 if (!con->input_enabled)
|
|
|
886 event_stream_select_console (con);
|
|
|
887 return Qnil;
|
|
|
888 }
|
|
|
889
|
|
|
890 DEFUN ("console-disable-input", Fconsole_disable_input, 1, 1, 0, /*
|
|
|
891 Disable input on console CONSOLE.
|
|
|
892 */
|
|
|
893 (console))
|
|
|
894 {
|
|
|
895 struct console *con = decode_console (console);
|
|
|
896 if (con->input_enabled)
|
|
|
897 event_stream_unselect_console (con);
|
|
|
898 return Qnil;
|
|
|
899 }
|
|
|
900
|
|
|
901 DEFUN ("console-on-window-system-p", Fconsole_on_window_system_p, 0, 1, 0, /*
|
|
444
|
902 Return t if CONSOLE is on a window system.
|
|
|
903 If CONSOLE is nil, the selected console is used.
|
|
428
|
904 This generally means that there is support for the mouse, the menubar,
|
|
|
905 the toolbar, glyphs, etc.
|
|
|
906 */
|
|
|
907 (console))
|
|
|
908 {
|
|
|
909 Lisp_Object type = CONSOLE_TYPE (decode_console (console));
|
|
|
910
|
|
|
911 return !EQ (type, Qtty) && !EQ (type, Qstream) ? Qt : Qnil;
|
|
|
912 }
|
|
|
913
|
|
|
914
|
|
|
915
|
|
|
916 /**********************************************************************/
|
|
|
917 /* Miscellaneous low-level functions */
|
|
|
918 /**********************************************************************/
|
|
|
919
|
|
|
920 static Lisp_Object
|
|
|
921 unwind_init_sys_modes (Lisp_Object console)
|
|
|
922 {
|
|
|
923 reinit_initial_console ();
|
|
|
924
|
|
|
925 if (!no_redraw_on_reenter &&
|
|
|
926 CONSOLEP (console) &&
|
|
|
927 CONSOLE_LIVE_P (XCONSOLE (console)))
|
|
|
928 {
|
|
|
929 struct frame *f =
|
|
|
930 XFRAME (DEVICE_SELECTED_FRAME
|
|
|
931 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (console)))));
|
|
|
932 MARK_FRAME_CHANGED (f);
|
|
|
933 }
|
|
|
934 return Qnil;
|
|
|
935 }
|
|
|
936
|
|
|
937 DEFUN ("suspend-emacs", Fsuspend_emacs, 0, 1, "", /*
|
|
|
938 Stop Emacs and return to superior process. You can resume later.
|
|
|
939 On systems that don't have job control, run a subshell instead.
|
|
|
940
|
|
|
941 If optional arg STUFFSTRING is non-nil, its characters are stuffed
|
|
|
942 to be read as terminal input by Emacs's superior shell.
|
|
|
943
|
|
|
944 Before suspending, run the normal hook `suspend-hook'.
|
|
|
945 After resumption run the normal hook `suspend-resume-hook'.
|
|
|
946
|
|
|
947 Some operating systems cannot stop the Emacs process and resume it later.
|
|
|
948 On such systems, Emacs will start a subshell and wait for it to exit.
|
|
|
949 */
|
|
|
950 (stuffstring))
|
|
|
951 {
|
|
|
952 int speccount = specpdl_depth ();
|
|
|
953 struct gcpro gcpro1;
|
|
|
954
|
|
|
955 if (!NILP (stuffstring))
|
|
|
956 CHECK_STRING (stuffstring);
|
|
|
957 GCPRO1 (stuffstring);
|
|
|
958
|
|
|
959 /* There used to be a check that the initial console is TTY.
|
|
|
960 This is bogus. Even checking to see whether any console
|
|
|
961 is a controlling terminal is not correct -- maybe
|
|
|
962 the user used the -t option or something. If we want to
|
|
|
963 suspend, then we suspend. Period. */
|
|
|
964
|
|
|
965 /* Call value of suspend-hook. */
|
|
|
966 run_hook (Qsuspend_hook);
|
|
|
967
|
|
|
968 reset_initial_console ();
|
|
|
969 /* sys_suspend can get an error if it tries to fork a subshell
|
|
|
970 and the system resources aren't available for that. */
|
|
|
971 record_unwind_protect (unwind_init_sys_modes, Vcontrolling_terminal);
|
|
|
972 stuff_buffered_input (stuffstring);
|
|
|
973 sys_suspend ();
|
|
|
974 /* the console is un-reset inside of the unwind-protect. */
|
|
771
|
975 unbind_to (speccount);
|
|
428
|
976
|
|
|
977 #ifdef SIGWINCH
|
|
|
978 /* It is possible that a size change occurred while we were
|
|
|
979 suspended. Assume one did just to be safe. It won't hurt
|
|
|
980 anything if one didn't. */
|
|
|
981 asynch_device_change_pending++;
|
|
|
982 #endif
|
|
|
983
|
|
|
984 /* Call value of suspend-resume-hook
|
|
|
985 if it is bound and value is non-nil. */
|
|
|
986 run_hook (Qsuspend_resume_hook);
|
|
|
987
|
|
|
988 UNGCPRO;
|
|
|
989 return Qnil;
|
|
|
990 }
|
|
|
991
|
|
|
992 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
|
|
|
993 Then in any case stuff anything Emacs has read ahead and not used. */
|
|
|
994
|
|
|
995 void
|
|
2286
|
996 stuff_buffered_input (
|
|
|
997 #ifdef BSD
|
|
|
998 Lisp_Object stuffstring
|
|
|
999 #else
|
|
|
1000 Lisp_Object UNUSED (stuffstring)
|
|
|
1001 #endif
|
|
|
1002 )
|
|
428
|
1003 {
|
|
|
1004 /* stuff_char works only in BSD, versions 4.2 and up. */
|
|
|
1005 #if defined (BSD)
|
|
|
1006 if (!CONSOLEP (Vcontrolling_terminal) ||
|
|
|
1007 !CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
|
|
|
1008 return;
|
|
|
1009
|
|
|
1010 if (STRINGP (stuffstring))
|
|
|
1011 {
|
|
665
|
1012 Bytecount count;
|
|
428
|
1013 Extbyte *p;
|
|
|
1014
|
|
440
|
1015 TO_EXTERNAL_FORMAT (LISP_STRING, stuffstring,
|
|
|
1016 ALLOCA, (p, count),
|
|
|
1017 Qkeyboard);
|
|
428
|
1018 while (count-- > 0)
|
|
|
1019 stuff_char (XCONSOLE (Vcontrolling_terminal), *p++);
|
|
|
1020 stuff_char (XCONSOLE (Vcontrolling_terminal), '\n');
|
|
|
1021 }
|
|
|
1022 /* Anything we have read ahead, put back for the shell to read. */
|
|
|
1023 # if 0 /* oh, who cares about this silliness */
|
|
|
1024 while (kbd_fetch_ptr != kbd_store_ptr)
|
|
|
1025 {
|
|
|
1026 if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
|
|
|
1027 kbd_fetch_ptr = kbd_buffer;
|
|
|
1028 stuff_char (XCONSOLE (Vcontrolling_terminal), *kbd_fetch_ptr++);
|
|
|
1029 }
|
|
|
1030 # endif
|
|
|
1031 #endif /* BSD */
|
|
|
1032 }
|
|
|
1033
|
|
|
1034 DEFUN ("suspend-console", Fsuspend_console, 0, 1, "", /*
|
|
|
1035 Suspend a console. For tty consoles, it sends a signal to suspend
|
|
|
1036 the process in charge of the tty, and removes the devices and
|
|
|
1037 frames of that console from the display.
|
|
|
1038
|
|
|
1039 If optional arg CONSOLE is non-nil, it is the console to be suspended.
|
|
|
1040 Otherwise it is assumed to be the selected console.
|
|
|
1041
|
|
|
1042 Some operating systems cannot stop processes and resume them later.
|
|
|
1043 On such systems, who knows what will happen.
|
|
|
1044 */
|
|
2340
|
1045 (USED_IF_TTY (console)))
|
|
428
|
1046 {
|
|
|
1047 #ifdef HAVE_TTY
|
|
|
1048 struct console *con = decode_console (console);
|
|
|
1049
|
|
|
1050 if (CONSOLE_TTY_P (con))
|
|
|
1051 {
|
|
|
1052 /*
|
|
|
1053 * hide all the unhidden frames so the display code won't update
|
|
|
1054 * them while the console is suspended.
|
|
|
1055 */
|
|
|
1056 Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
|
|
|
1057 if (!NILP (device))
|
|
|
1058 {
|
|
|
1059 struct device *d = XDEVICE (device);
|
|
|
1060 Lisp_Object frame_list = DEVICE_FRAME_LIST (d);
|
|
|
1061 while (CONSP (frame_list))
|
|
|
1062 {
|
|
|
1063 struct frame *f = XFRAME (XCAR (frame_list));
|
|
|
1064 if (FRAME_REPAINT_P (f))
|
|
|
1065 f->visible = -1;
|
|
|
1066 frame_list = XCDR (frame_list);
|
|
|
1067 }
|
|
|
1068 }
|
|
|
1069 reset_one_console (con);
|
|
|
1070 event_stream_unselect_console (con);
|
|
|
1071 sys_suspend_process (XINT (Fconsole_tty_controlling_process (console)));
|
|
|
1072 }
|
|
|
1073 #endif /* HAVE_TTY */
|
|
|
1074
|
|
|
1075 return Qnil;
|
|
|
1076 }
|
|
|
1077
|
|
|
1078 DEFUN ("resume-console", Fresume_console, 1, 1, "", /*
|
|
|
1079 Re-initialize a previously suspended console.
|
|
|
1080 For tty consoles, do stuff to the tty to make it sane again.
|
|
|
1081 */
|
|
2340
|
1082 (USED_IF_TTY (console)))
|
|
428
|
1083 {
|
|
|
1084 #ifdef HAVE_TTY
|
|
|
1085 struct console *con = decode_console (console);
|
|
|
1086
|
|
|
1087 if (CONSOLE_TTY_P (con))
|
|
|
1088 {
|
|
|
1089 /* raise the selected frame */
|
|
|
1090 Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
|
|
|
1091 if (!NILP (device))
|
|
|
1092 {
|
|
|
1093 struct device *d = XDEVICE (device);
|
|
|
1094 Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
|
|
|
1095 if (!NILP (frame))
|
|
|
1096 {
|
|
|
1097 /* force the frame to be cleared */
|
|
|
1098 SET_FRAME_CLEAR (XFRAME (frame));
|
|
|
1099 Fraise_frame (frame);
|
|
|
1100 }
|
|
|
1101 }
|
|
|
1102 init_one_console (con);
|
|
|
1103 event_stream_select_console (con);
|
|
|
1104 #ifdef SIGWINCH
|
|
|
1105 /* The same as in Fsuspend_emacs: it is possible that a size
|
|
|
1106 change occurred while we were suspended. Assume one did just
|
|
|
1107 to be safe. It won't hurt anything if one didn't. */
|
|
|
1108 asynch_device_change_pending++;
|
|
|
1109 #endif
|
|
|
1110 }
|
|
|
1111 #endif /* HAVE_TTY */
|
|
|
1112
|
|
|
1113 return Qnil;
|
|
|
1114 }
|
|
|
1115
|
|
|
1116 DEFUN ("set-input-mode", Fset_input_mode, 3, 5, 0, /*
|
|
|
1117 Set mode of reading keyboard input.
|
|
1204
|
1118 First arg (formerly INTERRUPT-INPUT) is ignored, for backward compatibility.
|
|
428
|
1119 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
|
|
|
1120 (no effect except in CBREAK mode).
|
|
|
1121 Third arg META t means accept 8-bit input (for a Meta key).
|
|
|
1122 META nil means ignore the top bit, on the assumption it is parity.
|
|
|
1123 Otherwise, accept 8-bit input and don't use the top bit for Meta.
|
|
|
1124 First three arguments only apply to TTY consoles.
|
|
|
1125 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
|
|
|
1126 Optional fifth arg CONSOLE specifies console to make changes to; nil means
|
|
|
1127 the selected console.
|
|
|
1128 See also `current-input-mode'.
|
|
|
1129 */
|
|
2340
|
1130 (UNUSED (ignored), USED_IF_TTY (flow), meta, quit, console))
|
|
428
|
1131 {
|
|
|
1132 struct console *con = decode_console (console);
|
|
|
1133 int meta_key = (!CONSOLE_TTY_P (con) ? 1 :
|
|
|
1134 EQ (meta, Qnil) ? 0 :
|
|
|
1135 EQ (meta, Qt) ? 1 :
|
|
|
1136 2);
|
|
|
1137
|
|
|
1138 if (!NILP (quit))
|
|
|
1139 {
|
|
1204
|
1140 if (CHAR_OR_CHAR_INTP (quit) && !meta_key)
|
|
|
1141 set_quit_events (con, make_char (XCHAR_OR_CHAR_INT (quit) & 0177));
|
|
|
1142 else
|
|
|
1143 set_quit_events (con, quit);
|
|
428
|
1144 }
|
|
|
1145
|
|
|
1146 #ifdef HAVE_TTY
|
|
|
1147 if (CONSOLE_TTY_P (con))
|
|
|
1148 {
|
|
|
1149 reset_one_console (con);
|
|
|
1150 TTY_FLAGS (con).flow_control = !NILP (flow);
|
|
|
1151 TTY_FLAGS (con).meta_key = meta_key;
|
|
|
1152 init_one_console (con);
|
|
444
|
1153 MARK_FRAME_CHANGED (XFRAME (CONSOLE_SELECTED_FRAME (con)));
|
|
428
|
1154 }
|
|
|
1155 #endif
|
|
|
1156
|
|
|
1157 return Qnil;
|
|
|
1158 }
|
|
|
1159
|
|
|
1160 DEFUN ("current-input-mode", Fcurrent_input_mode, 0, 1, 0, /*
|
|
|
1161 Return information about the way Emacs currently reads keyboard input.
|
|
|
1162 Optional arg CONSOLE specifies console to return information about; nil means
|
|
|
1163 the selected console.
|
|
|
1164 The value is a list of the form (nil FLOW META QUIT), where
|
|
|
1165 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
|
|
|
1166 terminal; this does not apply if Emacs uses interrupt-driven input.
|
|
|
1167 META is t if accepting 8-bit input with 8th bit as Meta flag.
|
|
|
1168 META nil means ignoring the top bit, on the assumption it is parity.
|
|
|
1169 META is neither t nor nil if accepting 8-bit input and using
|
|
|
1170 all 8 bits as the character code.
|
|
|
1171 QUIT is the character Emacs currently uses to quit.
|
|
|
1172 FLOW, and META are only meaningful for TTY consoles.
|
|
|
1173 The elements of this list correspond to the arguments of
|
|
|
1174 `set-input-mode'.
|
|
|
1175 */
|
|
|
1176 (console))
|
|
|
1177 {
|
|
|
1178 struct console *con = decode_console (console);
|
|
1204
|
1179 Lisp_Object flow, meta;
|
|
428
|
1180
|
|
|
1181 #ifdef HAVE_TTY
|
|
|
1182 flow = CONSOLE_TTY_P (con) && TTY_FLAGS (con).flow_control ? Qt : Qnil;
|
|
|
1183 meta = (!CONSOLE_TTY_P (con) ? Qt :
|
|
|
1184 TTY_FLAGS (con).meta_key == 1 ? Qt :
|
|
|
1185 TTY_FLAGS (con).meta_key == 2 ? Qzero :
|
|
|
1186 Qnil);
|
|
|
1187 #else
|
|
|
1188 flow = Qnil;
|
|
|
1189 meta = Qt;
|
|
|
1190 #endif
|
|
|
1191
|
|
1204
|
1192 return list4 (Qnil, flow, meta, CONSOLE_QUIT_CHAR (con));
|
|
428
|
1193 }
|
|
|
1194
|
|
|
1195
|
|
|
1196 /************************************************************************/
|
|
|
1197 /* initialization */
|
|
|
1198 /************************************************************************/
|
|
|
1199
|
|
|
1200 void
|
|
|
1201 syms_of_console (void)
|
|
|
1202 {
|
|
442
|
1203 INIT_LRECORD_IMPLEMENTATION (console);
|
|
|
1204
|
|
428
|
1205 DEFSUBR (Fvalid_console_type_p);
|
|
|
1206 DEFSUBR (Fconsole_type_list);
|
|
|
1207 DEFSUBR (Fcdfw_console);
|
|
|
1208 DEFSUBR (Fselected_console);
|
|
|
1209 DEFSUBR (Fselect_console);
|
|
|
1210 DEFSUBR (Fconsolep);
|
|
|
1211 DEFSUBR (Fconsole_live_p);
|
|
|
1212 DEFSUBR (Fconsole_type);
|
|
|
1213 DEFSUBR (Fconsole_name);
|
|
|
1214 DEFSUBR (Fconsole_connection);
|
|
|
1215 DEFSUBR (Ffind_console);
|
|
|
1216 DEFSUBR (Fget_console);
|
|
|
1217 DEFSUBR (Fdelete_console);
|
|
|
1218 DEFSUBR (Fconsole_list);
|
|
|
1219 DEFSUBR (Fconsole_device_list);
|
|
|
1220 DEFSUBR (Fconsole_enable_input);
|
|
|
1221 DEFSUBR (Fconsole_disable_input);
|
|
|
1222 DEFSUBR (Fconsole_on_window_system_p);
|
|
|
1223 DEFSUBR (Fsuspend_console);
|
|
|
1224 DEFSUBR (Fresume_console);
|
|
|
1225
|
|
|
1226 DEFSUBR (Fsuspend_emacs);
|
|
|
1227 DEFSUBR (Fset_input_mode);
|
|
|
1228 DEFSUBR (Fcurrent_input_mode);
|
|
|
1229
|
|
563
|
1230 DEFSYMBOL (Qconsolep);
|
|
|
1231 DEFSYMBOL (Qconsole_live_p);
|
|
428
|
1232
|
|
563
|
1233 DEFSYMBOL (Qcreate_console_hook);
|
|
|
1234 DEFSYMBOL (Qdelete_console_hook);
|
|
428
|
1235
|
|
563
|
1236 DEFSYMBOL (Qsuspend_hook);
|
|
|
1237 DEFSYMBOL (Qsuspend_resume_hook);
|
|
428
|
1238 }
|
|
|
1239
|
|
1204
|
1240 static const struct memory_description cte_description_1[] = {
|
|
440
|
1241 { XD_LISP_OBJECT, offsetof (console_type_entry, symbol) },
|
|
2551
|
1242 { XD_BLOCK_PTR, offsetof (console_type_entry, meths), 1,
|
|
|
1243 { &console_methods_description } },
|
|
428
|
1244 { XD_END }
|
|
|
1245 };
|
|
|
1246
|
|
1204
|
1247 static const struct sized_memory_description cte_description = {
|
|
440
|
1248 sizeof (console_type_entry),
|
|
428
|
1249 cte_description_1
|
|
|
1250 };
|
|
|
1251
|
|
1204
|
1252 static const struct memory_description cted_description_1[] = {
|
|
440
|
1253 XD_DYNARR_DESC (console_type_entry_dynarr, &cte_description),
|
|
428
|
1254 { XD_END }
|
|
|
1255 };
|
|
|
1256
|
|
1204
|
1257 const struct sized_memory_description cted_description = {
|
|
440
|
1258 sizeof (console_type_entry_dynarr),
|
|
428
|
1259 cted_description_1
|
|
|
1260 };
|
|
|
1261
|
|
1204
|
1262 static const struct memory_description console_methods_description_1[] = {
|
|
440
|
1263 { XD_LISP_OBJECT, offsetof (struct console_methods, symbol) },
|
|
|
1264 { XD_LISP_OBJECT, offsetof (struct console_methods, predicate_symbol) },
|
|
|
1265 { XD_LISP_OBJECT, offsetof (struct console_methods, image_conversion_list) },
|
|
428
|
1266 { XD_END }
|
|
|
1267 };
|
|
|
1268
|
|
1204
|
1269 const struct sized_memory_description console_methods_description = {
|
|
440
|
1270 sizeof (struct console_methods),
|
|
428
|
1271 console_methods_description_1
|
|
|
1272 };
|
|
|
1273
|
|
|
1274
|
|
|
1275 void
|
|
|
1276 console_type_create (void)
|
|
|
1277 {
|
|
|
1278 the_console_type_entry_dynarr = Dynarr_new (console_type_entry);
|
|
2367
|
1279 dump_add_root_block_ptr (&the_console_type_entry_dynarr, &cted_description);
|
|
428
|
1280
|
|
|
1281 Vconsole_type_list = Qnil;
|
|
|
1282 staticpro (&Vconsole_type_list);
|
|
|
1283
|
|
|
1284 /* Initialize the dead console type */
|
|
|
1285 INITIALIZE_CONSOLE_TYPE (dead, "dead", "console-dead-p");
|
|
|
1286
|
|
|
1287 /* then reset the console-type lists, because `dead' is not really
|
|
|
1288 a valid console type */
|
|
|
1289 Dynarr_reset (the_console_type_entry_dynarr);
|
|
|
1290 Vconsole_type_list = Qnil;
|
|
|
1291 }
|
|
|
1292
|
|
|
1293 void
|
|
|
1294 reinit_vars_of_console (void)
|
|
|
1295 {
|
|
|
1296 staticpro_nodump (&Vconsole_list);
|
|
|
1297 Vconsole_list = Qnil;
|
|
|
1298 staticpro_nodump (&Vselected_console);
|
|
|
1299 Vselected_console = Qnil;
|
|
|
1300 }
|
|
|
1301
|
|
|
1302 void
|
|
|
1303 vars_of_console (void)
|
|
|
1304 {
|
|
|
1305 DEFVAR_LISP ("create-console-hook", &Vcreate_console_hook /*
|
|
|
1306 Function or functions to call when a console is created.
|
|
|
1307 One argument, the newly-created console.
|
|
|
1308 This is called after the first frame has been created, but before
|
|
|
1309 calling the `create-device-hook' or `create-frame-hook'.
|
|
|
1310 Note that in general the console will not be selected.
|
|
|
1311 */ );
|
|
|
1312 Vcreate_console_hook = Qnil;
|
|
|
1313
|
|
|
1314 DEFVAR_LISP ("delete-console-hook", &Vdelete_console_hook /*
|
|
|
1315 Function or functions to call when a console is deleted.
|
|
|
1316 One argument, the to-be-deleted console.
|
|
|
1317 */ );
|
|
|
1318 Vdelete_console_hook = Qnil;
|
|
|
1319
|
|
|
1320 #ifdef HAVE_WINDOW_SYSTEM
|
|
|
1321 Fprovide (intern ("window-system"));
|
|
|
1322 #endif
|
|
|
1323 }
|
|
|
1324
|
|
643
|
1325 /* The docstrings for DEFVAR_* are recorded externally by make-docfile. */
|
|
2720
|
1326 #ifdef MC_ALLOC
|
|
|
1327 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magic_fun) \
|
|
|
1328 do { \
|
|
|
1329 struct symbol_value_forward *I_hate_C = \
|
|
|
1330 alloc_lrecord_type (struct symbol_value_forward, \
|
|
|
1331 &lrecord_symbol_value_forward); \
|
|
|
1332 /*mcpro ((Lisp_Object) I_hate_C);*/ \
|
|
|
1333 \
|
|
|
1334 I_hate_C->magic.value = &(console_local_flags.field_name); \
|
|
|
1335 I_hate_C->magic.type = forward_type; \
|
|
|
1336 I_hate_C->magicfun = magic_fun; \
|
|
|
1337 \
|
|
|
1338 MARK_LRECORD_AS_LISP_READONLY (I_hate_C); \
|
|
|
1339 \
|
|
|
1340 { \
|
|
|
1341 int offset = ((char *)symbol_value_forward_forward (I_hate_C) \
|
|
|
1342 - (char *)&console_local_flags); \
|
|
|
1343 \
|
|
|
1344 defvar_magic (lname, I_hate_C); \
|
|
|
1345 \
|
|
|
1346 *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols))) \
|
|
|
1347 = intern (lname); \
|
|
|
1348 } \
|
|
|
1349 } while (0)
|
|
|
1350 #else /* not MC_ALLOC */
|
|
617
|
1351 #define DEFVAR_CONSOLE_LOCAL_1(lname, field_name, forward_type, magicfun) \
|
|
|
1352 do { \
|
|
|
1353 static const struct symbol_value_forward I_hate_C = \
|
|
|
1354 { /* struct symbol_value_forward */ \
|
|
|
1355 { /* struct symbol_value_magic */ \
|
|
|
1356 { /* struct lcrecord_header */ \
|
|
|
1357 { /* struct lrecord_header */ \
|
|
|
1358 lrecord_type_symbol_value_forward, /* lrecord_type_index */ \
|
|
|
1359 1, /* mark bit */ \
|
|
|
1360 1, /* c_readonly bit */ \
|
|
|
1361 1 /* lisp_readonly bit */ \
|
|
|
1362 }, \
|
|
|
1363 0, /* next */ \
|
|
|
1364 0, /* uid */ \
|
|
|
1365 0 /* free */ \
|
|
|
1366 }, \
|
|
|
1367 &(console_local_flags.field_name), \
|
|
|
1368 forward_type \
|
|
|
1369 }, \
|
|
|
1370 magicfun \
|
|
|
1371 }; \
|
|
|
1372 \
|
|
|
1373 { \
|
|
|
1374 int offset = ((char *)symbol_value_forward_forward (&I_hate_C) \
|
|
|
1375 - (char *)&console_local_flags); \
|
|
|
1376 \
|
|
|
1377 defvar_magic (lname, &I_hate_C); \
|
|
|
1378 \
|
|
|
1379 *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols))) \
|
|
|
1380 = intern (lname); \
|
|
|
1381 } \
|
|
428
|
1382 } while (0)
|
|
2720
|
1383 #endif /* not MC_ALLOC */
|
|
428
|
1384
|
|
|
1385 #define DEFVAR_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
|
|
|
1386 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
|
|
|
1387 SYMVAL_SELECTED_CONSOLE_FORWARD, magicfun)
|
|
|
1388 #define DEFVAR_CONSOLE_LOCAL(lname, field_name) \
|
|
|
1389 DEFVAR_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
|
|
|
1390 #define DEFVAR_CONST_CONSOLE_LOCAL_MAGIC(lname, field_name, magicfun) \
|
|
|
1391 DEFVAR_CONSOLE_LOCAL_1 (lname, field_name, \
|
|
|
1392 SYMVAL_CONST_SELECTED_CONSOLE_FORWARD, magicfun)
|
|
|
1393 #define DEFVAR_CONST_CONSOLE_LOCAL(lname, field_name) \
|
|
|
1394 DEFVAR_CONST_CONSOLE_LOCAL_MAGIC (lname, field_name, 0)
|
|
|
1395
|
|
|
1396 #define DEFVAR_CONSOLE_DEFAULTS_MAGIC(lname, field_name, magicfun) \
|
|
|
1397 DEFVAR_SYMVAL_FWD(lname, &(console_local_flags.field_name), \
|
|
|
1398 SYMVAL_DEFAULT_CONSOLE_FORWARD, magicfun)
|
|
|
1399 #define DEFVAR_CONSOLE_DEFAULTS(lname, field_name) \
|
|
|
1400 DEFVAR_CONSOLE_DEFAULTS_MAGIC (lname, field_name, 0)
|
|
|
1401
|
|
|
1402 static void
|
|
|
1403 common_init_complex_vars_of_console (void)
|
|
|
1404 {
|
|
|
1405 /* Make sure all markable slots in console_defaults
|
|
|
1406 are initialized reasonably, so mark_console won't choke.
|
|
|
1407 */
|
|
2720
|
1408 #ifdef MC_ALLOC
|
|
|
1409 struct console *defs = alloc_lrecord_type (struct console, &lrecord_console);
|
|
|
1410 struct console *syms = alloc_lrecord_type (struct console, &lrecord_console);
|
|
|
1411 #else /* not MC_ALLOC */
|
|
428
|
1412 struct console *defs = alloc_lcrecord_type (struct console, &lrecord_console);
|
|
|
1413 struct console *syms = alloc_lcrecord_type (struct console, &lrecord_console);
|
|
2720
|
1414 #endif /* not MC_ALLOC */
|
|
428
|
1415
|
|
|
1416 staticpro_nodump (&Vconsole_defaults);
|
|
|
1417 staticpro_nodump (&Vconsole_local_symbols);
|
|
793
|
1418 Vconsole_defaults = wrap_console (defs);
|
|
|
1419 Vconsole_local_symbols = wrap_console (syms);
|
|
428
|
1420
|
|
|
1421 nuke_all_console_slots (syms, Qnil);
|
|
|
1422 nuke_all_console_slots (defs, Qnil);
|
|
|
1423
|
|
|
1424 /* Set up the non-nil default values of various console slots.
|
|
|
1425 Must do these before making the first console.
|
|
|
1426 */
|
|
1204
|
1427
|
|
|
1428 /* ... Nothing here for the moment.
|
|
|
1429 #### Console-local variables should probably be eliminated.*/
|
|
428
|
1430
|
|
|
1431 {
|
|
|
1432 /* 0 means var is always local. Default used only at creation.
|
|
|
1433 * -1 means var is always local. Default used only at reset and
|
|
|
1434 * creation.
|
|
|
1435 * -2 means there's no lisp variable corresponding to this slot
|
|
|
1436 * and the default is only used at creation.
|
|
|
1437 * -3 means no Lisp variable. Default used only at reset and creation.
|
|
|
1438 * >0 is mask. Var is local if ((console->local_var_flags & mask) != 0)
|
|
|
1439 * Otherwise default is used.
|
|
|
1440 *
|
|
|
1441 * #### We don't currently ever reset console variables, so there
|
|
|
1442 * is no current distinction between 0 and -1, and between -2 and -3.
|
|
|
1443 */
|
|
|
1444 Lisp_Object always_local_resettable = make_int (-1);
|
|
|
1445
|
|
|
1446 #if 0 /* not used */
|
|
|
1447 Lisp_Object always_local_no_default = make_int (0);
|
|
|
1448 Lisp_Object resettable = make_int (-3);
|
|
|
1449 #endif
|
|
|
1450
|
|
|
1451 /* Assign the local-flags to the slots that have default values.
|
|
|
1452 The local flag is a bit that is used in the console
|
|
|
1453 to say that it has its own local value for the slot.
|
|
|
1454 The local flag bits are in the local_var_flags slot of the
|
|
|
1455 console. */
|
|
|
1456
|
|
|
1457 nuke_all_console_slots (&console_local_flags, make_int (-2));
|
|
|
1458 console_local_flags.defining_kbd_macro = always_local_resettable;
|
|
|
1459 console_local_flags.last_kbd_macro = always_local_resettable;
|
|
|
1460 console_local_flags.prefix_arg = always_local_resettable;
|
|
|
1461 console_local_flags.default_minibuffer_frame = always_local_resettable;
|
|
|
1462 console_local_flags.overriding_terminal_local_map =
|
|
|
1463 always_local_resettable;
|
|
|
1464 #ifdef HAVE_TTY
|
|
|
1465 console_local_flags.tty_erase_char = always_local_resettable;
|
|
|
1466 #endif
|
|
|
1467
|
|
|
1468 console_local_flags.function_key_map = make_int (1);
|
|
|
1469
|
|
|
1470 /* #### Warning, 0x4000000 (that's six zeroes) is the largest number
|
|
|
1471 currently allowable due to the XINT() handling of this value.
|
|
|
1472 With some rearrangement you can get 4 more bits. */
|
|
|
1473 }
|
|
|
1474 }
|
|
|
1475
|
|
|
1476
|
|
|
1477 #define CONSOLE_SLOTS_SIZE (offsetof (struct console, CONSOLE_SLOTS_LAST_NAME) - offsetof (struct console, CONSOLE_SLOTS_FIRST_NAME) + sizeof (Lisp_Object))
|
|
|
1478 #define CONSOLE_SLOTS_COUNT (CONSOLE_SLOTS_SIZE / sizeof (Lisp_Object))
|
|
|
1479
|
|
|
1480 void
|
|
771
|
1481 reinit_complex_vars_of_console_runtime_only (void)
|
|
428
|
1482 {
|
|
|
1483 struct console *defs, *syms;
|
|
|
1484
|
|
|
1485 common_init_complex_vars_of_console ();
|
|
|
1486
|
|
|
1487 defs = XCONSOLE (Vconsole_defaults);
|
|
|
1488 syms = XCONSOLE (Vconsole_local_symbols);
|
|
|
1489 memcpy (&defs->CONSOLE_SLOTS_FIRST_NAME,
|
|
|
1490 console_defaults_saved_slots,
|
|
|
1491 CONSOLE_SLOTS_SIZE);
|
|
|
1492 memcpy (&syms->CONSOLE_SLOTS_FIRST_NAME,
|
|
|
1493 console_local_symbols_saved_slots,
|
|
|
1494 CONSOLE_SLOTS_SIZE);
|
|
|
1495 }
|
|
|
1496
|
|
|
1497
|
|
1204
|
1498 static const struct memory_description console_slots_description_1[] = {
|
|
440
|
1499 { XD_LISP_OBJECT_ARRAY, 0, CONSOLE_SLOTS_COUNT },
|
|
428
|
1500 { XD_END }
|
|
|
1501 };
|
|
|
1502
|
|
1204
|
1503 static const struct sized_memory_description console_slots_description = {
|
|
428
|
1504 CONSOLE_SLOTS_SIZE,
|
|
|
1505 console_slots_description_1
|
|
|
1506 };
|
|
|
1507
|
|
|
1508 void
|
|
|
1509 complex_vars_of_console (void)
|
|
|
1510 {
|
|
|
1511 struct console *defs, *syms;
|
|
|
1512
|
|
|
1513 common_init_complex_vars_of_console ();
|
|
|
1514
|
|
|
1515 defs = XCONSOLE (Vconsole_defaults);
|
|
|
1516 syms = XCONSOLE (Vconsole_local_symbols);
|
|
|
1517 console_defaults_saved_slots = &defs->CONSOLE_SLOTS_FIRST_NAME;
|
|
|
1518 console_local_symbols_saved_slots = &syms->CONSOLE_SLOTS_FIRST_NAME;
|
|
2367
|
1519 dump_add_root_block_ptr (&console_defaults_saved_slots, &console_slots_description);
|
|
|
1520 dump_add_root_block_ptr (&console_local_symbols_saved_slots, &console_slots_description);
|
|
428
|
1521
|
|
|
1522 DEFVAR_CONSOLE_DEFAULTS ("default-function-key-map", function_key_map /*
|
|
|
1523 Default value of `function-key-map' for consoles that don't override it.
|
|
|
1524 This is the same as (default-value 'function-key-map).
|
|
|
1525 */ );
|
|
|
1526
|
|
|
1527 DEFVAR_CONSOLE_LOCAL ("function-key-map", function_key_map /*
|
|
|
1528 Keymap mapping ASCII function key sequences onto their preferred forms.
|
|
|
1529 This allows Emacs to recognize function keys sent from ASCII
|
|
|
1530 terminals at any point in a key sequence.
|
|
|
1531
|
|
|
1532 The `read-key-sequence' function replaces any subsequence bound by
|
|
|
1533 `function-key-map' with its binding. More precisely, when the active
|
|
|
1534 keymaps have no binding for the current key sequence but
|
|
|
1535 `function-key-map' binds a suffix of the sequence to a vector or string,
|
|
|
1536 `read-key-sequence' replaces the matching suffix with its binding, and
|
|
2027
|
1537 continues with the new sequence. See `key-binding'.
|
|
428
|
1538
|
|
|
1539 The events that come from bindings in `function-key-map' are not
|
|
|
1540 themselves looked up in `function-key-map'.
|
|
|
1541
|
|
|
1542 For example, suppose `function-key-map' binds `ESC O P' to [f1].
|
|
|
1543 Typing `ESC O P' to `read-key-sequence' would return
|
|
|
1544 \[#<keypress-event f1>]. Typing `C-x ESC O P' would return
|
|
|
1545 \[#<keypress-event control-X> #<keypress-event f1>]. If [f1]
|
|
|
1546 were a prefix key, typing `ESC O P x' would return
|
|
|
1547 \[#<keypress-event f1> #<keypress-event x>].
|
|
|
1548 */ );
|
|
|
1549
|
|
|
1550 #ifdef HAVE_TTY
|
|
440
|
1551 /* #### Should this somehow go to TTY data? How do we make it
|
|
428
|
1552 accessible from Lisp, then? */
|
|
|
1553 DEFVAR_CONSOLE_LOCAL ("tty-erase-char", tty_erase_char /*
|
|
|
1554 The ERASE character as set by the user with stty.
|
|
|
1555 When this value cannot be determined or would be meaningless (on non-TTY
|
|
|
1556 consoles, for example), it is set to nil.
|
|
|
1557 */ );
|
|
|
1558 #endif
|
|
|
1559
|
|
442
|
1560 /* While this should be const it can't be because some things
|
|
428
|
1561 (i.e. edebug) do manipulate it. */
|
|
|
1562 DEFVAR_CONSOLE_LOCAL ("defining-kbd-macro", defining_kbd_macro /*
|
|
442
|
1563 Non-nil while a keyboard macro is being defined. Don't set this!
|
|
428
|
1564 */ );
|
|
|
1565
|
|
|
1566 DEFVAR_CONSOLE_LOCAL ("last-kbd-macro", last_kbd_macro /*
|
|
442
|
1567 Last keyboard macro defined, as a vector of events; nil if none defined.
|
|
428
|
1568 */ );
|
|
|
1569
|
|
|
1570 DEFVAR_CONSOLE_LOCAL ("prefix-arg", prefix_arg /*
|
|
|
1571 The value of the prefix argument for the next editing command.
|
|
|
1572 It may be a number, or the symbol `-' for just a minus sign as arg,
|
|
|
1573 or a list whose car is a number for just one or more C-U's
|
|
|
1574 or nil if no argument has been specified.
|
|
|
1575
|
|
|
1576 You cannot examine this variable to find the argument for this command
|
|
|
1577 since it has been set to nil by the time you can look.
|
|
|
1578 Instead, you should use the variable `current-prefix-arg', although
|
|
|
1579 normally commands can get this prefix argument with (interactive "P").
|
|
|
1580 */ );
|
|
|
1581
|
|
|
1582 DEFVAR_CONSOLE_LOCAL ("default-minibuffer-frame",
|
|
|
1583 default_minibuffer_frame /*
|
|
|
1584 Minibufferless frames use this frame's minibuffer.
|
|
|
1585
|
|
|
1586 Emacs cannot create minibufferless frames unless this is set to an
|
|
|
1587 appropriate surrogate.
|
|
|
1588
|
|
|
1589 XEmacs consults this variable only when creating minibufferless
|
|
|
1590 frames; once the frame is created, it sticks with its assigned
|
|
|
1591 minibuffer, no matter what this variable is set to. This means that
|
|
|
1592 this variable doesn't necessarily say anything meaningful about the
|
|
|
1593 current set of frames, or where the minibuffer is currently being
|
|
|
1594 displayed.
|
|
|
1595 */ );
|
|
|
1596
|
|
|
1597 DEFVAR_CONSOLE_LOCAL ("overriding-terminal-local-map",
|
|
|
1598 overriding_terminal_local_map /*
|
|
|
1599 Keymap that overrides all other local keymaps, for the selected console only.
|
|
|
1600 If this variable is non-nil, it is used as a keymap instead of the
|
|
|
1601 buffer's local map, and the minor mode keymaps and text property keymaps.
|
|
|
1602 */ );
|
|
|
1603
|
|
|
1604 /* Check for DEFVAR_CONSOLE_LOCAL without initializing the corresponding
|
|
|
1605 slot of console_local_flags and vice-versa. Must be done after all
|
|
|
1606 DEFVAR_CONSOLE_LOCAL() calls. */
|
|
|
1607 #define MARKED_SLOT(slot) \
|
|
|
1608 if ((XINT (console_local_flags.slot) != -2 && \
|
|
|
1609 XINT (console_local_flags.slot) != -3) \
|
|
|
1610 != !(NILP (XCONSOLE (Vconsole_local_symbols)->slot))) \
|
|
2500
|
1611 ABORT ();
|
|
428
|
1612 #include "conslots.h"
|
|
|
1613 }
|
