src/console.c

   1 /* The console object.
   2    Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
   3    Copyright (C) 1996 Ben Wing.
   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
  24 /* Written by Ben Wing. */
  25
  26 #include <config.h>
  27 #include "lisp.h"
  28
  29 #include "buffer.h"
  30 #include "console-tty.h"
  31 #include "events.h"
  32 #include "frame.h"
  33 #include "redisplay.h"
  34 #include "sysdep.h"
  35 #include "window.h"
  36
  37 Lisp_Object Vconsole_list, Vselected_console;
  38
  39 Lisp_Object Vcreate_console_hook, Vdelete_console_hook;
  40
  41 Lisp_Object Qconsolep, Qconsole_live_p;
  42 Lisp_Object Qcreate_console_hook;
  43 Lisp_Object Qdelete_console_hook;
  44
  45 Lisp_Object Qsuspend_hook;
  46 Lisp_Object Qsuspend_resume_hook;
  47
  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;
  57
  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.
  62
  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.
  66
  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
  70    consoles.
  71
  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.
  75
  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.
  79
  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.
  83
  84
  85    */
  86 struct console console_local_flags;
  87
  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;
  92
  93 DEFINE_CONSOLE_TYPE (dead);
  94
  95 Lisp_Object Vconsole_type_list;
  96
  97 console_type_entry_dynarr *the_console_type_entry_dynarr;
  98
  99 \f
 100 static Lisp_Object
 101 mark_console (Lisp_Object obj)
 102 {
 103   struct console *con = XCONSOLE (obj);
 104
 105 #define MARKED_SLOT(x) mark_object (con->x)
 106 #include "conslots.h"
 107 #undef MARKED_SLOT
 108
 109   /* Can be zero for Vconsole_defaults, Vconsole_local_symbols */
 110   if (con->conmeths)
 111     {
 112       mark_object (con->conmeths->symbol);
 113       MAYBE_CONMETH (con, mark_console, (con));
 114     }
 115
 116   return Qnil;
 117 }
 118
 119 static void
 120 print_console (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 121 {
 122   struct console *con = XCONSOLE (obj);
 123   char buf[256];
 124
 125   if (print_readably)
 126     error ("printing unreadable object #<console %s 0x%x>",
 127            XSTRING_DATA (con->name), con->header.uid);
 128
 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)))
 133     {
 134       write_c_string (" on ", printcharfun);
 135       print_internal (CONSOLE_CONNECTION (con), printcharfun, 1);
 136     }
 137   sprintf (buf, " 0x%x>", con->header.uid);
 138   write_c_string (buf, printcharfun);
 139 }
 140
 141 DEFINE_LRECORD_IMPLEMENTATION ("console", console,
 142                                mark_console, print_console, 0, 0, 0, 0,
 143                                struct console);
 144 \f
 145 static struct console *
 146 allocate_console (void)
 147 {
 148   Lisp_Object console;
 149   struct console *con = alloc_lcrecord_type (struct console, &lrecord_console);
 150   struct gcpro gcpro1;
 151
 152   copy_lcrecord (con, XCONSOLE (Vconsole_defaults));
 153
 154   XSETCONSOLE (console, con);
 155   GCPRO1 (console);
 156
 157   con->quit_char = 7; /* C-g */
 158   con->command_builder = allocate_command_builder (console);
 159   con->function_key_map = Fmake_sparse_keymap (Qnil);
 160
 161   UNGCPRO;
 162   return con;
 163 }
 164
 165 struct console *
 166 decode_console (Lisp_Object console)
 167 {
 168   if (NILP (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);
 175 }
 176
 177
 178 struct console_methods *
 179 decode_console_type (Lisp_Object type, Error_behavior errb)
 180 {
 181   int i;
 182
 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;
 186
 187   maybe_signal_simple_error ("Invalid console type", type, Qconsole, errb);
 188
 189   return 0;
 190 }
 191
 192 int
 193 valid_console_type_p (Lisp_Object type)
 194 {
 195   return decode_console_type (type, ERROR_ME_NOT) != 0;
 196 }
 197
 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.
 201 */
 202        (console_type))
 203 {
 204   return valid_console_type_p (console_type) ? Qt : Qnil;
 205 }
 206
 207 DEFUN ("console-type-list", Fconsole_type_list, 0, 0, 0, /*
 208 Return a list of valid console types.
 209 */
 210        ())
 211 {
 212   return Fcopy_sequence (Vconsole_type_list);
 213 }
 214
 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.
 218 */
 219        (object))
 220 {
 221   return CDFW_CONSOLE (object);
 222 }
 223
 224 \f
 225 DEFUN ("selected-console", Fselected_console, 0, 0, 0, /*
 226 Return the console which is currently active.
 227 */
 228        ())
 229 {
 230   return Vselected_console;
 231 }
 232
 233 /* Called from selected_device_1(), called from selected_frame_1(),
 234    called from Fselect_window() */
 235 void
 236 select_console_1 (Lisp_Object console)
 237 {
 238   /* perhaps this should do something more complicated */
 239   Vselected_console = console;
 240
 241   /* #### Schedule this to be removed in 19.14 */
 242 #ifdef HAVE_X_WINDOWS
 243   if (CONSOLE_X_P (XCONSOLE (console)))
 244     Vwindow_system = Qx;
 245   else
 246 #endif
 247 #ifdef HAVE_GTK
 248   if (CONSOLE_GTK_P (XCONSOLE (console)))
 249     Vwindow_system = Qgtk;
 250   else
 251 #endif
 252 #ifdef HAVE_MS_WINDOWS
 253   if (CONSOLE_MSWINDOWS_P (XCONSOLE (console)))
 254     Vwindow_system = Qmswindows;
 255   else
 256 #endif
 257     Vwindow_system = Qnil;
 258 }
 259
 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.
 266 */
 267        (console))
 268 {
 269   Lisp_Object device;
 270
 271   CHECK_LIVE_CONSOLE (console);
 272
 273   device = CONSOLE_SELECTED_DEVICE (XCONSOLE (console));
 274   if (!NILP (device))
 275     {
 276       struct device *d = XDEVICE (device);
 277       Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
 278       if (!NILP (frame))
 279         {
 280           struct frame *f = XFRAME(frame);
 281           Fselect_window (FRAME_SELECTED_WINDOW (f), Qnil);
 282         }
 283       else
 284         error ("Can't select console with no frames.");
 285     }
 286   else
 287     error ("Can't select a console with no devices");
 288   return Qnil;
 289 }
 290
 291 void
 292 set_console_last_nonminibuf_frame (struct console *con,
 293                                    Lisp_Object frame)
 294 {
 295   con->last_nonminibuf_frame = frame;
 296 }
 297
 298 DEFUN ("consolep", Fconsolep, 1, 1, 0, /*
 299 Return non-nil if OBJECT is a console.
 300 */
 301        (object))
 302 {
 303   return CONSOLEP (object) ? Qt : Qnil;
 304 }
 305
 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.
 308 */
 309        (object))
 310 {
 311   return CONSOLEP (object) && CONSOLE_LIVE_P (XCONSOLE (object)) ? Qt : Qnil;
 312 }
 313
 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
 320   implemented),
 321 `stream' for a stream console (which acts like a stdio stream), and
 322 `dead' for a deleted console.
 323 */
 324        (console))
 325 {
 326   /* don't call decode_console() because we want to allow for dead
 327      consoles. */
 328   if (NILP (console))
 329     console = Fselected_console ();
 330   CHECK_CONSOLE (console);
 331   return CONSOLE_TYPE (XCONSOLE (console));
 332 }
 333
 334 DEFUN ("console-name", Fconsole_name, 0, 1, 0, /*
 335 Return the name of CONSOLE.
 336 */
 337        (console))
 338 {
 339   return CONSOLE_NAME (decode_console (console));
 340 }
 341
 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.
 345 */
 346        (console))
 347 {
 348   return CONSOLE_CONNECTION (decode_console (console));
 349 }
 350
 351 Lisp_Object
 352 make_console (struct console *con)
 353 {
 354   Lisp_Object console;
 355   XSETCONSOLE (console, con);
 356   return console;
 357 }
 358
 359 static Lisp_Object
 360 semi_canonicalize_console_connection (struct console_methods *meths,
 361                                       Lisp_Object name, Error_behavior errb)
 362 {
 363   if (HAS_CONTYPE_METH_P (meths, semi_canonicalize_console_connection))
 364     return CONTYPE_METH (meths, semi_canonicalize_console_connection,
 365                          (name, errb));
 366   else
 367     return CONTYPE_METH_OR_GIVEN (meths, canonicalize_console_connection,
 368                                   (name, errb), name);
 369 }
 370
 371 static Lisp_Object
 372 canonicalize_console_connection (struct console_methods *meths,
 373                                  Lisp_Object name, Error_behavior errb)
 374 {
 375   if (HAS_CONTYPE_METH_P (meths, canonicalize_console_connection))
 376     return CONTYPE_METH (meths, canonicalize_console_connection,
 377                          (name, errb));
 378   else
 379     return CONTYPE_METH_OR_GIVEN (meths, semi_canonicalize_console_connection,
 380                                   (name, errb), name);
 381 }
 382
 383 static Lisp_Object
 384 find_console_of_type (struct console_methods *meths, Lisp_Object canon)
 385 {
 386   Lisp_Object concons;
 387
 388   CONSOLE_LOOP (concons)
 389     {
 390       Lisp_Object console = XCAR (concons);
 391
 392       if (EQ (CONMETH_TYPE (meths), CONSOLE_TYPE (XCONSOLE (console)))
 393           && internal_equal (CONSOLE_CANON_CONNECTION (XCONSOLE (console)),
 394                              canon, 0))
 395         return console;
 396     }
 397
 398   return Qnil;
 399 }
 400
 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.
 404
 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.)
 409 */
 410        (connection, type))
 411 {
 412   Lisp_Object canon = Qnil;
 413   struct gcpro gcpro1;
 414
 415   GCPRO1 (canon);
 416
 417   if (!NILP (type))
 418     {
 419       struct console_methods *conmeths = decode_console_type (type, ERROR_ME);
 420       canon = canonicalize_console_connection (conmeths, connection,
 421                                                ERROR_ME_NOT);
 422       if (UNBOUNDP (canon))
 423         RETURN_UNGCPRO (Qnil);
 424
 425       RETURN_UNGCPRO (find_console_of_type (conmeths, canon));
 426     }
 427   else
 428     {
 429       int i;
 430
 431       for (i = 0; i < Dynarr_length (the_console_type_entry_dynarr); i++)
 432         {
 433           struct console_methods *conmeths =
 434             Dynarr_at (the_console_type_entry_dynarr, i).meths;
 435           canon = canonicalize_console_connection (conmeths, connection,
 436                                                    ERROR_ME_NOT);
 437           if (!UNBOUNDP (canon))
 438             {
 439               Lisp_Object console = find_console_of_type (conmeths, canon);
 440               if (!NILP (console))
 441                 RETURN_UNGCPRO (console);
 442             }
 443         }
 444
 445       RETURN_UNGCPRO (Qnil);
 446     }
 447 }
 448
 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.
 452
 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.)
 457 */
 458        (connection, type))
 459 {
 460   Lisp_Object console = Ffind_console (connection, type);
 461   if (NILP (console))
 462     {
 463       if (NILP (type))
 464         signal_simple_error ("No such console", connection);
 465       else
 466         signal_simple_error_2 ("No such console", type, connection);
 467     }
 468   return console;
 469 }
 470
 471 Lisp_Object
 472 create_console (Lisp_Object name, Lisp_Object type, Lisp_Object connection,
 473                 Lisp_Object props)
 474 {
 475   /* This function can GC */
 476   struct console *con;
 477   Lisp_Object console;
 478   struct gcpro gcpro1;
 479
 480   console = Ffind_console (connection, type);
 481   if (!NILP (console))
 482     return console;
 483
 484   con = allocate_console ();
 485   XSETCONSOLE (console, con);
 486
 487   GCPRO1 (console);
 488
 489   con->conmeths = decode_console_type (type, ERROR_ME);
 490
 491   CONSOLE_NAME (con) = name;
 492   CONSOLE_CONNECTION (con) =
 493     semi_canonicalize_console_connection (con->conmeths, connection,
 494                                           ERROR_ME);
 495   CONSOLE_CANON_CONNECTION (con) =
 496     canonicalize_console_connection (con->conmeths, connection,
 497                                      ERROR_ME);
 498
 499   MAYBE_CONMETH (con, init_console, (con, props));
 500
 501   /* Do it this way so that the console list is in order of creation */
 502   Vconsole_list = nconc2 (Vconsole_list, Fcons (console, Qnil));
 503
 504   if (CONMETH_OR_GIVEN (con, initially_selected_for_input, (con), 0))
 505     event_stream_select_console (con);
 506
 507   UNGCPRO;
 508   return console;
 509 }
 510
 511 void
 512 add_entry_to_console_type_list (Lisp_Object symbol,
 513                                 struct console_methods *meths)
 514 {
 515   struct console_type_entry entry;
 516
 517   entry.symbol = symbol;
 518   entry.meths = meths;
 519   Dynarr_add (the_console_type_entry_dynarr, entry);
 520   Vconsole_type_list = Fcons (symbol, Vconsole_type_list);
 521 }
 522
 523 /* find a console other than the selected one.  Prefer non-stream
 524    consoles over stream consoles. */
 525
 526 static Lisp_Object
 527 find_other_console (Lisp_Object console)
 528 {
 529   Lisp_Object concons;
 530
 531   /* look for a non-stream console */
 532   CONSOLE_LOOP (concons)
 533     {
 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))))))
 540         break;
 541     }
 542   if (!NILP (concons))
 543     return XCAR (concons);
 544
 545   /* OK, now look for a stream console */
 546   CONSOLE_LOOP (concons)
 547     {
 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))))))
 553         break;
 554     }
 555   if (!NILP (concons))
 556     return XCAR (concons);
 557
 558   /* Sorry, there ain't none */
 559   return Qnil;
 560 }
 561
 562 static int
 563 find_nonminibuffer_frame_not_on_console_predicate (Lisp_Object frame,
 564                                                    void *closure)
 565 {
 566   Lisp_Object console;
 567
 568   VOID_TO_LISP (console, closure);
 569   if (FRAME_MINIBUF_ONLY_P (XFRAME (frame)))
 570     return 0;
 571   if (EQ (console, FRAME_CONSOLE (XFRAME (frame))))
 572     return 0;
 573   return 1;
 574 }
 575
 576 static Lisp_Object
 577 find_nonminibuffer_frame_not_on_console (Lisp_Object console)
 578 {
 579   return find_some_frame (find_nonminibuffer_frame_not_on_console_predicate,
 580                           LISP_TO_VOID (console));
 581 }
 582
 583 /* Delete console CON.
 584
 585    If FORCE is non-zero, allow deletion of the only frame.
 586
 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'.
 590
 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'.)
 594 */
 595
 596 void
 597 delete_console_internal (struct console *con, int force,
 598                          int called_from_kill_emacs, int from_io_error)
 599 {
 600   /* This function can GC */
 601   Lisp_Object console;
 602   struct gcpro gcpro1;
 603
 604   /* OK to delete an already-deleted console. */
 605   if (!CONSOLE_LIVE_P (con))
 606     return;
 607
 608   XSETCONSOLE (console, con);
 609   GCPRO1 (console);
 610
 611   if (!called_from_kill_emacs)
 612     {
 613       int down_we_go = 0;
 614
 615       if ((XINT (Flength (Vconsole_list)) == 1)
 616           /* if we just created the console, it might not be listed,
 617              or something ... */
 618           && !NILP (memq_no_quit (console, Vconsole_list)))
 619         down_we_go = 1;
 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)))
 623         down_we_go = 1;
 624
 625       if (down_we_go)
 626         {
 627           if (!force)
 628             error ("Attempt to delete the only frame");
 629           else if (from_io_error)
 630             {
 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));
 636             }
 637           else
 638             {
 639               call0 (Qsave_buffers_kill_emacs);
 640               UNGCPRO;
 641               /* If we get here, the user said they didn't want
 642                  to exit, so don't. */
 643               return;
 644             }
 645         }
 646     }
 647
 648   /* Breathe a sigh of relief.  We're still alive. */
 649
 650   {
 651     Lisp_Object frmcons, devcons;
 652
 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.
 656
 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.
 663
 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)
 668       {
 669         struct frame *f = XFRAME (XCAR (frmcons));
 670         /* delete_frame_internal() might do anything such as run hooks,
 671            so be defensive. */
 672         if (FRAME_LIVE_P (f) && !FRAME_HAS_MINIBUF_P (f))
 673           delete_frame_internal (f, 1, 1, from_io_error);
 674
 675         if (!CONSOLE_LIVE_P (con)) /* make sure the delete-*-hook didn't
 676                                       go ahead and delete anything */
 677           {
 678             UNGCPRO;
 679             return;
 680           }
 681       }
 682
 683     CONSOLE_DEVICE_LOOP (devcons, con)
 684       {
 685         struct device *d = XDEVICE (XCAR (devcons));
 686         /* delete_device_internal() might do anything such as run hooks,
 687            so be defensive. */
 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 */
 692           {
 693             UNGCPRO;
 694             return;
 695           }
 696       }
 697   }
 698
 699   CONSOLE_SELECTED_DEVICE (con) = Qnil;
 700
 701   /* try to select another console */
 702
 703   if (EQ (console, Fselected_console ()))
 704     {
 705       Lisp_Object other_dev = find_other_console (console);
 706       if (!NILP (other_dev))
 707         Fselect_console (other_dev);
 708       else
 709         {
 710           /* necessary? */
 711           Vselected_console = Qnil;
 712           Vwindow_system = Qnil;
 713         }
 714     }
 715
 716   if (con->input_enabled)
 717     event_stream_unselect_console (con);
 718
 719   MAYBE_CONMETH (con, delete_console, (con));
 720
 721   Vconsole_list = delq_no_quit (console, Vconsole_list);
 722   RESET_CHANGED_SET_FLAGS;
 723   con->conmeths = dead_console_methods;
 724
 725   UNGCPRO;
 726 }
 727
 728 void
 729 io_error_delete_console (Lisp_Object console)
 730 {
 731   delete_console_internal (XCONSOLE (console), 1, 0, 1);
 732 }
 733
 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'.)
 740 */
 741        (console, force))
 742 {
 743   CHECK_CONSOLE (console);
 744   delete_console_internal (XCONSOLE (console), !NILP (force), 0, 0);
 745   return Qnil;
 746 }
 747
 748 DEFUN ("console-list", Fconsole_list, 0, 0, 0, /*
 749 Return a list of all consoles.
 750 */
 751        ())
 752 {
 753   return Fcopy_sequence (Vconsole_list);
 754 }
 755
 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.
 759 */
 760        (console))
 761 {
 762   return Fcopy_sequence (CONSOLE_DEVICE_LIST (decode_console (console)));
 763 }
 764
 765 DEFUN ("console-enable-input", Fconsole_enable_input, 1, 1, 0, /*
 766 Enable input on console CONSOLE.
 767 */
 768        (console))
 769 {
 770   struct console *con = decode_console (console);
 771   if (!con->input_enabled)
 772     event_stream_select_console (con);
 773   return Qnil;
 774 }
 775
 776 DEFUN ("console-disable-input", Fconsole_disable_input, 1, 1, 0, /*
 777 Disable input on console CONSOLE.
 778 */
 779        (console))
 780 {
 781   struct console *con = decode_console (console);
 782   if (con->input_enabled)
 783     event_stream_unselect_console (con);
 784   return Qnil;
 785 }
 786
 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.
 792 */
 793        (console))
 794 {
 795   Lisp_Object type = CONSOLE_TYPE (decode_console (console));
 796
 797   return !EQ (type, Qtty) && !EQ (type, Qstream) ? Qt : Qnil;
 798 }
 799
 800
 801 \f
 802 /**********************************************************************/
 803 /*               Miscellaneous low-level functions                    */
 804 /**********************************************************************/
 805
 806 static Lisp_Object
 807 unwind_init_sys_modes (Lisp_Object console)
 808 {
 809   reinit_initial_console ();
 810
 811   if (!no_redraw_on_reenter &&
 812       CONSOLEP (console) &&
 813       CONSOLE_LIVE_P (XCONSOLE (console)))
 814     {
 815       struct frame *f =
 816         XFRAME (DEVICE_SELECTED_FRAME
 817                 (XDEVICE (CONSOLE_SELECTED_DEVICE (XCONSOLE (console)))));
 818       MARK_FRAME_CHANGED (f);
 819     }
 820   return Qnil;
 821 }
 822
 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.
 826
 827 If optional arg STUFFSTRING is non-nil, its characters are stuffed
 828 to be read as terminal input by Emacs's superior shell.
 829
 830 Before suspending, run the normal hook `suspend-hook'.
 831 After resumption run the normal hook `suspend-resume-hook'.
 832
 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.
 835 */
 836        (stuffstring))
 837 {
 838   int speccount = specpdl_depth ();
 839   struct gcpro gcpro1;
 840
 841   if (!NILP (stuffstring))
 842     CHECK_STRING (stuffstring);
 843   GCPRO1 (stuffstring);
 844
 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. */
 850
 851   /* Call value of suspend-hook. */
 852   run_hook (Qsuspend_hook);
 853
 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);
 859   sys_suspend ();
 860   /* the console is un-reset inside of the unwind-protect. */
 861   unbind_to (speccount, Qnil);
 862
 863 #ifdef SIGWINCH
 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++;
 868 #endif
 869
 870   /* Call value of suspend-resume-hook
 871      if it is bound and value is non-nil.  */
 872   run_hook (Qsuspend_resume_hook);
 873
 874   UNGCPRO;
 875   return Qnil;
 876 }
 877
 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.  */
 880
 881 void
 882 stuff_buffered_input (Lisp_Object stuffstring)
 883 {
 884 /* stuff_char works only in BSD, versions 4.2 and up.  */
 885 #if defined (BSD)
 886   if (!CONSOLEP (Vcontrolling_terminal) ||
 887       !CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
 888     return;
 889
 890   if (STRINGP (stuffstring))
 891     {
 892       Extcount count;
 893       Extbyte *p;
 894
 895       TO_EXTERNAL_FORMAT (LISP_STRING, stuffstring,
 896                           ALLOCA, (p, count),
 897                           Qkeyboard);
 898       while (count-- > 0)
 899         stuff_char (XCONSOLE (Vcontrolling_terminal), *p++);
 900       stuff_char (XCONSOLE (Vcontrolling_terminal), '\n');
 901     }
 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)
 905     {
 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++);
 909     }
 910 # endif
 911 #endif /* BSD */
 912 }
 913
 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.
 918
 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.
 921
 922 Some operating systems cannot stop processes and resume them later.
 923 On such systems, who knows what will happen.
 924 */
 925        (console))
 926 {
 927 #ifdef HAVE_TTY
 928   struct console *con = decode_console (console);
 929
 930   if (CONSOLE_TTY_P (con))
 931     {
 932       /*
 933        * hide all the unhidden frames so the display code won't update
 934        * them while the console is suspended.
 935        */
 936       Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
 937       if (!NILP (device))
 938         {
 939           struct device *d = XDEVICE (device);
 940           Lisp_Object frame_list = DEVICE_FRAME_LIST (d);
 941           while (CONSP (frame_list))
 942             {
 943               struct frame *f = XFRAME (XCAR (frame_list));
 944               if (FRAME_REPAINT_P (f))
 945                 f->visible = -1;
 946               frame_list = XCDR (frame_list);
 947             }
 948         }
 949       reset_one_console (con);
 950       event_stream_unselect_console (con);
 951       sys_suspend_process (XINT (Fconsole_tty_controlling_process (console)));
 952     }
 953 #endif /* HAVE_TTY */
 954
 955   return Qnil;
 956 }
 957
 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.
 961 */
 962        (console))
 963 {
 964 #ifdef HAVE_TTY
 965   struct console *con = decode_console (console);
 966
 967   if (CONSOLE_TTY_P (con))
 968     {
 969       /* raise the selected frame */
 970       Lisp_Object device = CONSOLE_SELECTED_DEVICE (con);
 971       if (!NILP (device))
 972         {
 973           struct device *d = XDEVICE (device);
 974           Lisp_Object frame = DEVICE_SELECTED_FRAME (d);
 975           if (!NILP (frame))
 976             {
 977               /* force the frame to be cleared */
 978               SET_FRAME_CLEAR (XFRAME (frame));
 979               Fraise_frame (frame);
 980             }
 981         }
 982       init_one_console (con);
 983       event_stream_select_console (con);
 984 #ifdef SIGWINCH
 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++;
 989 #endif
 990     }
 991 #endif /* HAVE_TTY */
 992
 993   return Qnil;
 994 }
 995
 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'.
1009 */
1010      (ignored, flow, meta, quit, console))
1011 {
1012   struct console *con = decode_console (console);
1013   int meta_key = (!CONSOLE_TTY_P (con) ? 1 :
1014                   EQ (meta, Qnil)      ? 0 :
1015                   EQ (meta, Qt)        ? 1 :
1016                   2);
1017
1018   if (!NILP (quit))
1019     {
1020       CHECK_CHAR_COERCE_INT (quit);
1021       CONSOLE_QUIT_CHAR (con) =
1022         ((unsigned int) XCHAR (quit)) & (meta_key ? 0377 : 0177);
1023     }
1024
1025 #ifdef HAVE_TTY
1026   if (CONSOLE_TTY_P (con))
1027     {
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)));
1033     }
1034 #endif
1035
1036   return Qnil;
1037 }
1038
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
1053 `set-input-mode'.
1054 */
1055        (console))
1056 {
1057   struct console *con = decode_console (console);
1058   Lisp_Object flow, meta, quit;
1059
1060 #ifdef HAVE_TTY
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 :
1065           Qnil);
1066 #else
1067   flow = Qnil;
1068   meta = Qt;
1069 #endif
1070   quit = make_char (CONSOLE_QUIT_CHAR (con));
1071
1072   return list4 (Qnil, flow, meta, quit);
1073 }
1074
1075 \f
1076 /************************************************************************/
1077 /*                            initialization                            */
1078 /************************************************************************/
1079
1080 void
1081 syms_of_console (void)
1082 {
1083   INIT_LRECORD_IMPLEMENTATION (console);
1084
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);
1105
1106   DEFSUBR (Fsuspend_emacs);
1107   DEFSUBR (Fset_input_mode);
1108   DEFSUBR (Fcurrent_input_mode);
1109
1110   defsymbol (&Qconsolep, "consolep");
1111   defsymbol (&Qconsole_live_p, "console-live-p");
1112
1113   defsymbol (&Qcreate_console_hook, "create-console-hook");
1114   defsymbol (&Qdelete_console_hook, "delete-console-hook");
1115
1116   defsymbol (&Qsuspend_hook, "suspend-hook");
1117   defsymbol (&Qsuspend_resume_hook, "suspend-resume-hook");
1118 }
1119
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 },
1123   { XD_END }
1124 };
1125
1126 static const struct struct_description cte_description = {
1127   sizeof (console_type_entry),
1128   cte_description_1
1129 };
1130
1131 static const struct lrecord_description cted_description_1[] = {
1132   XD_DYNARR_DESC (console_type_entry_dynarr, &cte_description),
1133   { XD_END }
1134 };
1135
1136 const struct struct_description cted_description = {
1137   sizeof (console_type_entry_dynarr),
1138   cted_description_1
1139 };
1140
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) },
1145   { XD_END }
1146 };
1147
1148 const struct struct_description console_methods_description = {
1149   sizeof (struct console_methods),
1150   console_methods_description_1
1151 };
1152
1153
1154 void
1155 console_type_create (void)
1156 {
1157   the_console_type_entry_dynarr = Dynarr_new (console_type_entry);
1158   dump_add_root_struct_ptr (&the_console_type_entry_dynarr, &cted_description);
1159
1160   Vconsole_type_list = Qnil;
1161   staticpro (&Vconsole_type_list);
1162
1163   /* Initialize the dead console type */
1164   INITIALIZE_CONSOLE_TYPE (dead, "dead", "console-dead-p");
1165
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;
1170 }
1171
1172 void
1173 reinit_vars_of_console (void)
1174 {
1175   staticpro_nodump (&Vconsole_list);
1176   Vconsole_list = Qnil;
1177   staticpro_nodump (&Vselected_console);
1178   Vselected_console = Qnil;
1179 }
1180
1181 void
1182 vars_of_console (void)
1183 {
1184   reinit_vars_of_console ();
1185
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.
1192 */ );
1193   Vcreate_console_hook = Qnil;
1194
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.
1198 */ );
1199   Vdelete_console_hook = Qnil;
1200
1201 #ifdef HAVE_WINDOW_SYSTEM
1202   Fprovide (intern ("window-system"));
1203 #endif
1204 }
1205
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 */           \
1214           1, /* mark bit */                                                     \
1215           1, /* c_readonly bit */                                               \
1216           1  /* lisp_readonly bit */                                            \
1217         },                                                                      \
1218         0, /* next */                                                           \
1219         0, /* uid  */                                                           \
1220         0  /* free */                                                           \
1221       },                                                                        \
1222       &(console_local_flags.field_name),                                        \
1223       forward_type                                                              \
1224     },                                                                          \
1225     magicfun                                                                    \
1226   };                                                                            \
1227                                                                                 \
1228   {                                                                             \
1229     int offset = ((char *)symbol_value_forward_forward (&I_hate_C)              \
1230                   - (char *)&console_local_flags);                              \
1231                                                                                 \
1232     defvar_magic (lname, &I_hate_C);                                            \
1233                                                                                 \
1234     *((Lisp_Object *)(offset + (char *)XCONSOLE (Vconsole_local_symbols)))      \
1235       = intern (lname);                                                         \
1236   }                                                                             \
1237 } while (0)
1238
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)
1249
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)
1255
1256 static void
1257 nuke_all_console_slots (struct console *con, Lisp_Object zap)
1258 {
1259   zero_lcrecord (con);
1260
1261 #define MARKED_SLOT(x)  con->x = zap
1262 #include "conslots.h"
1263 #undef MARKED_SLOT
1264 }
1265
1266 static void
1267 common_init_complex_vars_of_console (void)
1268 {
1269   /* Make sure all markable slots in console_defaults
1270      are initialized reasonably, so mark_console won't choke.
1271    */
1272   struct console *defs = alloc_lcrecord_type (struct console, &lrecord_console);
1273   struct console *syms = alloc_lcrecord_type (struct console, &lrecord_console);
1274
1275   staticpro_nodump (&Vconsole_defaults);
1276   staticpro_nodump (&Vconsole_local_symbols);
1277   XSETCONSOLE (Vconsole_defaults, defs);
1278   XSETCONSOLE (Vconsole_local_symbols, syms);
1279
1280   nuke_all_console_slots (syms, Qnil);
1281   nuke_all_console_slots (defs, Qnil);
1282
1283   /* Set up the non-nil default values of various console slots.
1284      Must do these before making the first console.
1285      */
1286   /* #### Anything needed here? */
1287
1288   {
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
1291      *    creation.
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.
1297      *
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.
1300      */
1301     Lisp_Object always_local_resettable = make_int (-1);
1302
1303 #if 0 /* not used */
1304     Lisp_Object always_local_no_default = make_int (0);
1305     Lisp_Object resettable = make_int (-3);
1306 #endif
1307
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
1312        console.  */
1313
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;
1321 #ifdef HAVE_TTY
1322     console_local_flags.tty_erase_char = always_local_resettable;
1323 #endif
1324
1325     console_local_flags.function_key_map = make_int (1);
1326
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. */
1330   }
1331 }
1332
1333
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))
1336
1337 void
1338 reinit_complex_vars_of_console (void)
1339 {
1340   struct console *defs, *syms;
1341
1342   common_init_complex_vars_of_console ();
1343
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);
1352 }
1353
1354
1355 static const struct lrecord_description console_slots_description_1[] = {
1356   { XD_LISP_OBJECT_ARRAY, 0, CONSOLE_SLOTS_COUNT },
1357   { XD_END }
1358 };
1359
1360 static const struct struct_description console_slots_description = {
1361   CONSOLE_SLOTS_SIZE,
1362   console_slots_description_1
1363 };
1364
1365 void
1366 complex_vars_of_console (void)
1367 {
1368   struct console *defs, *syms;
1369
1370   common_init_complex_vars_of_console ();
1371
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);
1378
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).
1382 */ );
1383
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.
1388
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'.
1395
1396 The events that come from bindings in `function-key-map' are not
1397 themselves looked up in `function-key-map'.
1398
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>].
1405 */ );
1406
1407 #ifdef HAVE_TTY
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.
1414 */ );
1415 #endif
1416
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!
1421 */ );
1422
1423   DEFVAR_CONSOLE_LOCAL ("last-kbd-macro", last_kbd_macro /*
1424 Last keyboard macro defined, as a vector of events; nil if none defined.
1425 */ );
1426
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.
1432
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").
1437 */ );
1438
1439   DEFVAR_CONSOLE_LOCAL ("default-minibuffer-frame",
1440                         default_minibuffer_frame /*
1441 Minibufferless frames use this frame's minibuffer.
1442
1443 Emacs cannot create minibufferless frames unless this is set to an
1444 appropriate surrogate.
1445
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
1451 displayed.
1452 */ );
1453
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.
1459 */ );
1460
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)))     \
1468   ABORT ()
1469 #include "conslots.h"
1470 #undef MARKED_SLOT
1471 }