src/emacs.c

   1 /* Fully extensible Emacs, running on Unix, intended for GNU.
   2    Copyright (C) 1985, 1986, 1987, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20
  21 #include <signal.h>
  22 #include <errno.h>
  23
  24 #include "config.h"
  25 #include <stdio.h>
  26
  27 #include <sys/types.h>
  28 #include <sys/file.h>
  29
  30 #ifdef VMS
  31 #include <ssdef.h>
  32 #endif
  33
  34 #ifdef BSD
  35 #include <sys/ioctl.h>
  36 #endif
  37
  38 #ifdef APOLLO
  39 #ifndef APOLLO_SR10
  40 #include <default_acl.h>
  41 #endif
  42 #endif
  43
  44 #include "lisp.h"
  45 #include "commands.h"
  46 #include "intervals.h"
  47
  48 #include "systty.h"
  49 #include "syssignal.h"
  50
  51 #ifndef O_RDWR
  52 #define O_RDWR 2
  53 #endif
  54
  55 #define PRIO_PROCESS 0
  56
  57 /* Command line args from shell, as list of strings */
  58 Lisp_Object Vcommand_line_args;
  59
  60 /* The name under which Emacs was invoked, with any leading directory
  61    names discarded.  */
  62 Lisp_Object Vinvocation_name;
  63
  64 /* Hook run by `kill-emacs' before it does really anything.  */
  65 Lisp_Object Vkill_emacs_hook;
  66
  67 /* Set nonzero after Emacs has started up the first time.
  68   Prevents reinitialization of the Lisp world and keymaps
  69   on subsequent starts.  */
  70 int initialized;
  71
  72 /* Variable whose value is symbol giving operating system type */
  73 Lisp_Object Vsystem_type;
  74
  75 /* If non-zero, emacs should not attempt to use an window-specific code,
  76    but instead should use the virtual terminal under which it was started */
  77 int inhibit_window_system;
  78
  79 /* If nonzero, set Emacs to run at this priority.  This is also used
  80    in child_setup and sys_suspend to make sure subshells run at normal
  81    priority; Those functions have their own extern declaration.  */
  82 int emacs_priority;
  83
  84 #ifdef BSD
  85 /* See sysdep.c.  */
  86 extern int inherited_pgroup;
  87 #endif
  88
  89 #ifdef HAVE_X_WINDOWS
  90 /* If non-zero, -d was specified, meaning we're using some window system. */
  91 int display_arg;
  92 #endif
  93
  94 /* An address near the bottom of the stack.
  95    Tells GC how to save a copy of the stack.  */
  96 char *stack_bottom;
  97
  98 #ifdef HAVE_X_WINDOWS
  99 extern Lisp_Object Vwindow_system;
 100 #endif /* HAVE_X_WINDOWS */
 101
 102 #ifdef USG_SHARED_LIBRARIES
 103 /* If nonzero, this is the place to put the end of the writable segment
 104    at startup.  */
 105
 106 unsigned int bss_end = 0;
 107 #endif
 108
 109 /* Nonzero means running Emacs without interactive terminal.  */
 110
 111 int noninteractive;
 112
 113 /* Value of Lisp variable `noninteractive'.
 114    Normally same as C variable `noninteractive'
 115    but nothing terrible happens if user sets this one.  */
 116
 117 int noninteractive1;
 118 \f
 119 /* Signal code for the fatal signal that was received */
 120 int fatal_error_code;
 121
 122 /* Nonzero if handling a fatal error already */
 123 int fatal_error_in_progress;
 124
 125 /* Handle bus errors, illegal instruction, etc. */
 126 SIGTYPE
 127 fatal_error_signal (sig)
 128      int sig;
 129 {
 130   fatal_error_code = sig;
 131   signal (sig, SIG_DFL);
 132
 133   /* If fatal error occurs in code below, avoid infinite recursion.  */
 134   if (! fatal_error_in_progress)
 135     {
 136       fatal_error_in_progress = 1;
 137
 138       shut_down_emacs (sig, 0, Qnil);
 139     }
 140
 141 #ifdef VMS
 142   LIB$STOP (SS$_ABORT);
 143 #else
 144   /* Signal the same code; this time it will really be fatal.
 145      Remember that since we're in a signal handler, the signal we're
 146      going to send is probably blocked, so we have to unblock it if we
 147      want to really receive it.  */
 148   sigunblock (sigmask (fatal_error_code));
 149   kill (getpid (), fatal_error_code);
 150 #endif /* not VMS */
 151 }
 152 \f
 153 /* Code for dealing with Lisp access to the Unix command line */
 154
 155 static
 156 init_cmdargs (argc, argv, skip_args)
 157      int argc;
 158      char **argv;
 159      int skip_args;
 160 {
 161   register int i;
 162
 163   Vinvocation_name = Ffile_name_nondirectory (build_string (argv[0]));
 164
 165   Vcommand_line_args = Qnil;
 166
 167   for (i = argc - 1; i >= 0; i--)
 168     {
 169       if (i == 0 || i > skip_args)
 170         Vcommand_line_args
 171           = Fcons (build_string (argv[i]), Vcommand_line_args);
 172     }
 173 }
 174
 175 DEFUN ("invocation-name", Finvocation_name, Sinvocation_name, 0, 0, 0,
 176   "Return the program name that was used to run Emacs.\n\
 177 Any directory names are omitted.")
 178   ()
 179 {
 180   return Fcopy_sequence (Vinvocation_name);
 181 }
 182
 183 \f
 184 #ifdef VMS
 185 #ifdef LINK_CRTL_SHARE
 186 #ifdef SHAREABLE_LIB_BUG
 187 extern noshare char **environ;
 188 #endif /* SHAREABLE_LIB_BUG */
 189 #endif /* LINK_CRTL_SHARE */
 190 #endif /* VMS */
 191
 192 #ifndef ORDINARY_LINK
 193 /* We don't include crtbegin.o and crtend.o in the link,
 194    so these functions and variables might be missed.
 195    Provide dummy definitions to avoid error.
 196    (We don't have any real constructors or destructors.)  */
 197 #ifdef __GNUC__
 198 __do_global_ctors ()
 199 {}
 200 __do_global_ctors_aux ()
 201 {}
 202 __do_global_dtors ()
 203 {}
 204 char * __CTOR_LIST__[2] = { (char *) (-1), 0 };
 205 char * __DTOR_LIST__[2] = { (char *) (-1), 0 };
 206 __main ()
 207 {}
 208 #endif /* __GNUC__ */
 209 #endif /* ORDINARY_LINK */
 210
 211 /* ARGSUSED */
 212 main (argc, argv, envp)
 213      int argc;
 214      char **argv;
 215      char **envp;
 216 {
 217   char stack_bottom_variable;
 218   int skip_args = 0;
 219   extern int errno;
 220   extern sys_nerr;
 221   extern char *sys_errlist[];
 222   extern void malloc_warning ();
 223
 224 /* Map in shared memory, if we are using that.  */
 225 #ifdef HAVE_SHM
 226   if (argc > 1 && !strcmp (argv[1], "-nl"))
 227     {
 228       map_in_data (0);
 229       /* The shared memory was just restored, which clobbered this.  */
 230       skip_args = 1;
 231     }
 232   else
 233     {
 234       map_in_data (1);
 235       /* The shared memory was just restored, which clobbered this.  */
 236       skip_args = 0;
 237     }
 238 #endif
 239
 240 #ifdef NeXT
 241   extern int malloc_cookie;
 242
 243   /* This helps out unexnext.c.  */
 244   if (initialized)
 245     if (malloc_jumpstart (malloc_cookie) != 0)
 246       printf ("malloc jumpstart failed!\n");
 247 #endif /* NeXT */
 248
 249 #ifdef HAVE_X_WINDOWS
 250   /* Stupid kludge to catch command-line display spec.  We can't
 251      handle this argument entirely in window system dependent code
 252      because we don't even know which window system dependent code
 253      to run until we've recognized this argument.  */
 254   {
 255     int i;
 256
 257     for (i = 1; (i < argc && ! display_arg); i++)
 258       if (!strcmp (argv[i], "-d") || !strcmp (argv[i], "-display"))
 259         display_arg = 1;
 260   }
 261 #endif
 262
 263 #ifdef VMS
 264   /* If -map specified, map the data file in */
 265   if (argc > 2 && ! strcmp (argv[1], "-map"))
 266     {
 267       skip_args = 2;
 268       mapin_data (argv[2]);
 269     }
 270
 271 #ifdef LINK_CRTL_SHARE
 272 #ifdef SHAREABLE_LIB_BUG
 273   /* Bletcherous shared libraries! */
 274   if (!stdin)
 275     stdin = fdopen (0, "r");
 276   if (!stdout)
 277     stdout = fdopen (1, "w");
 278   if (!stderr)
 279     stderr = fdopen (2, "w");
 280   if (!environ)
 281     environ = envp;
 282 #endif /* SHAREABLE_LIB_BUG */
 283 #endif /* LINK_CRTL_SHARE */
 284 #endif /* VMS */
 285
 286   /* Record (approximately) where the stack begins.  */
 287   stack_bottom = &stack_bottom_variable;
 288
 289 #ifdef RUN_TIME_REMAP
 290   if (initialized)
 291     run_time_remap (argv[0]);
 292 #endif
 293
 294 #ifdef USG_SHARED_LIBRARIES
 295   if (bss_end)
 296     brk (bss_end);
 297 #endif
 298
 299   clearerr (stdin);
 300
 301 #ifdef BSD
 302   {
 303     inherited_pgroup = getpgrp (0);
 304     setpgrp (0, getpid ());
 305   }
 306 #endif
 307
 308
 309 #ifdef APOLLO
 310 #ifndef APOLLO_SR10
 311   /* If USE_DOMAIN_ACLS environment variable exists,
 312      use ACLs rather than UNIX modes. */
 313   if (egetenv ("USE_DOMAIN_ACLS"))
 314     default_acl (USE_DEFACL);
 315 #endif
 316 #endif /* APOLLO */
 317
 318 #ifndef SYSTEM_MALLOC
 319   if (! initialized)
 320     {
 321       /* Arrange to get warning messages as memory fills up.  */
 322       memory_warnings (0, malloc_warning);
 323
 324       /* Arrange to disable interrupt input while malloc and friends are
 325          running.  */
 326       uninterrupt_malloc ();
 327     }
 328 #endif  /* not SYSTEM_MALLOC */
 329
 330 #ifdef PRIO_PROCESS
 331   if (emacs_priority)
 332     nice (emacs_priority);
 333   setuid (getuid ());
 334 #endif /* PRIO_PROCESS */
 335
 336   inhibit_window_system = 0;
 337
 338   /* Handle the -t switch, which specifies filename to use as terminal */
 339   if (skip_args + 2 < argc && !strcmp (argv[skip_args + 1], "-t"))
 340     {
 341       int result;
 342       skip_args += 2;
 343       close (0);
 344       close (1);
 345       result = open (argv[skip_args], O_RDWR, 2 );
 346       if (result < 0)
 347         {
 348           char *errstring;
 349
 350           if (errno >= 0 && errno < sys_nerr)
 351             errstring = sys_errlist[errno];
 352           else
 353             errstring = "undocumented error code";
 354           fprintf (stderr, "emacs: %s: %s\n", argv[skip_args], errstring);
 355           exit (1);
 356         }
 357       dup (0);
 358       if (! isatty (0))
 359         {
 360           fprintf (stderr, "emacs: %s: not a tty\n", argv[skip_args]);
 361           exit (1);
 362         }
 363       fprintf (stderr, "Using %s\n", argv[skip_args]);
 364 #ifdef HAVE_X_WINDOWS
 365       inhibit_window_system = 1;        /* -t => -nw */
 366 #endif
 367     }
 368
 369   if (skip_args + 1 < argc
 370       && (!strcmp (argv[skip_args + 1], "-nw")))
 371     {
 372       skip_args += 1;
 373       inhibit_window_system = 1;
 374     }
 375
 376 /* Handle the -batch switch, which means don't do interactive display.  */
 377   noninteractive = 0;
 378   if (skip_args + 1 < argc && !strcmp (argv[skip_args + 1], "-batch"))
 379     {
 380       skip_args += 1;
 381       noninteractive = 1;
 382     }
 383
 384 #ifdef POSIX_SIGNALS
 385   init_signals ();
 386 #endif
 387
 388   if (
 389 #ifndef CANNOT_DUMP
 390       ! noninteractive || initialized
 391 #else
 392       1
 393 #endif
 394       )
 395     {
 396       /* Don't catch these signals in batch mode if not initialized.
 397          On some machines, this sets static data that would make
 398          signal fail to work right when the dumped Emacs is run.  */
 399       signal (SIGHUP, fatal_error_signal);
 400       signal (SIGQUIT, fatal_error_signal);
 401       signal (SIGILL, fatal_error_signal);
 402       signal (SIGTRAP, fatal_error_signal);
 403 #ifdef SIGIOT
 404       /* This is missing on some systems - OS/2, for example.  */
 405       signal (SIGIOT, fatal_error_signal);
 406 #endif
 407 #ifdef SIGEMT
 408       signal (SIGEMT, fatal_error_signal);
 409 #endif
 410       signal (SIGFPE, fatal_error_signal);
 411 #ifdef SIGBUS
 412       signal (SIGBUS, fatal_error_signal);
 413 #endif
 414       signal (SIGSEGV, fatal_error_signal);
 415 #ifdef SIGSYS
 416       signal (SIGSYS, fatal_error_signal);
 417 #endif
 418       signal (SIGTERM, fatal_error_signal);
 419 #ifdef SIGXCPU
 420       signal (SIGXCPU, fatal_error_signal);
 421 #endif
 422 #ifdef SIGXFSZ
 423       signal (SIGXFSZ, fatal_error_signal);
 424 #endif /* SIGXFSZ */
 425
 426 #ifdef AIX
 427       signal (SIGDANGER, fatal_error_signal);
 428       signal (20, fatal_error_signal);
 429       signal (21, fatal_error_signal);
 430       signal (22, fatal_error_signal);
 431       signal (23, fatal_error_signal);
 432       signal (24, fatal_error_signal);
 433 #ifdef SIGIO
 434       signal (SIGAIO, fatal_error_signal);
 435       signal (SIGPTY, fatal_error_signal);
 436 #endif
 437 #ifndef _I386
 438       signal (SIGIOINT, fatal_error_signal);
 439 #endif
 440       signal (SIGGRANT, fatal_error_signal);
 441       signal (SIGRETRACT, fatal_error_signal);
 442       signal (SIGSOUND, fatal_error_signal);
 443       signal (SIGMSG, fatal_error_signal);
 444 #endif /* AIX */
 445     }
 446
 447   noninteractive1 = noninteractive;
 448
 449 /* Perform basic initializations (not merely interning symbols) */
 450
 451   if (!initialized)
 452     {
 453       init_alloc_once ();
 454       init_obarray ();
 455       init_eval_once ();
 456       init_syntax_once ();      /* Create standard syntax table.  */
 457                       /* Must be done before init_buffer */
 458       init_casetab_once ();
 459       init_buffer_once ();      /* Create buffer table and some buffers */
 460       init_minibuf_once ();     /* Create list of minibuffers */
 461                               /* Must precede init_window_once */
 462       init_window_once ();      /* Init the window system */
 463     }
 464
 465   init_alloc ();
 466   init_eval ();
 467   init_data ();
 468
 469   /* egetenv is a pretty low-level facility, which may get called in
 470      many circumstances; it seems flimsy to put off initializing it
 471      until calling init_callproc.  */
 472   set_process_environment ();
 473
 474   init_lread ();
 475
 476   init_cmdargs (argc, argv, skip_args); /* Create list Vcommand_line_args */
 477   init_buffer ();       /* Init default directory of main buffer */
 478   if (!noninteractive)
 479     {
 480 #ifdef VMS
 481       init_vms_input ();/* init_display calls get_frame_size, that needs this */
 482 #endif /* VMS */
 483       init_display ();  /* Determine terminal type.  init_sys_modes uses results */
 484     }
 485   init_keyboard ();     /* This too must precede init_sys_modes */
 486   init_callproc ();     /* And this too. */
 487 #ifdef VMS
 488   init_vmsproc ();      /* And this too. */
 489 #endif /* VMS */
 490   init_sys_modes ();    /* Init system terminal modes (RAW or CBREAK, etc.) */
 491   init_xdisp ();
 492   init_macros ();
 493   init_editfns ();
 494 #ifdef LISP_FLOAT_TYPE
 495   init_floatfns ();
 496 #endif
 497 #ifdef VMS
 498   init_vmsfns ();
 499 #endif /* VMS */
 500   init_process ();
 501 #ifdef CLASH_DETECTION
 502   init_filelock ();
 503 #endif /* CLASH_DETECTION */
 504
 505 /* Intern the names of all standard functions and variables; define standard keys */
 506
 507   if (!initialized)
 508     {
 509       /* The basic levels of Lisp must come first */
 510       /* And data must come first of all
 511          for the sake of symbols like error-message */
 512       syms_of_data ();
 513       syms_of_alloc ();
 514       syms_of_lread ();
 515       syms_of_print ();
 516       syms_of_eval ();
 517       syms_of_fns ();
 518 #ifdef LISP_FLOAT_TYPE
 519       syms_of_floatfns ();
 520 #endif
 521
 522       syms_of_abbrev ();
 523       syms_of_buffer ();
 524       syms_of_bytecode ();
 525       syms_of_callint ();
 526       syms_of_casefiddle ();
 527       syms_of_casetab ();
 528       syms_of_callproc ();
 529       syms_of_cmds ();
 530 #ifndef NO_DIR_LIBRARY
 531       syms_of_dired ();
 532 #endif /* not NO_DIR_LIBRARY */
 533       syms_of_display ();
 534       syms_of_doc ();
 535       syms_of_editfns ();
 536       syms_of_emacs ();
 537       syms_of_fileio ();
 538 #ifdef CLASH_DETECTION
 539       syms_of_filelock ();
 540 #endif /* CLASH_DETECTION */
 541       syms_of_indent ();
 542       syms_of_keyboard ();
 543       syms_of_keymap ();
 544       syms_of_macros ();
 545       syms_of_marker ();
 546       syms_of_minibuf ();
 547       syms_of_mocklisp ();
 548       syms_of_process ();
 549       syms_of_search ();
 550       syms_of_frame ();
 551       syms_of_syntax ();
 552       syms_of_undo ();
 553
 554       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
 555       syms_of_textprop ();
 556 #ifdef VMS
 557       syms_of_vmsproc ();
 558 #endif /* VMS */
 559       syms_of_window ();
 560       syms_of_xdisp ();
 561 #ifdef HAVE_X_WINDOWS
 562       syms_of_xterm ();
 563       syms_of_xfns ();
 564       syms_of_xfaces ();
 565 #ifdef HAVE_X11
 566       syms_of_xselect ();
 567 #endif
 568 #ifdef HAVE_X_MENU
 569       syms_of_xmenu ();
 570 #endif /* HAVE_X_MENU */
 571 #endif /* HAVE_X_WINDOWS */
 572
 573 #ifdef SYMS_SYSTEM
 574       SYMS_SYSTEM;
 575 #endif
 576
 577 #ifdef SYMS_MACHINE
 578       SYMS_MACHINE;
 579 #endif
 580
 581       keys_of_casefiddle ();
 582       keys_of_cmds ();
 583       keys_of_buffer ();
 584       keys_of_keyboard ();
 585       keys_of_keymap ();
 586       keys_of_macros ();
 587       keys_of_minibuf ();
 588       keys_of_window ();
 589       keys_of_frame ();
 590     }
 591
 592   if (!initialized)
 593     {
 594       /* Handle -l loadup-and-dump, args passed by Makefile. */
 595       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
 596         Vtop_level = Fcons (intern ("load"),
 597                             Fcons (build_string (argv[2 + skip_args]), Qnil));
 598 #ifdef CANNOT_DUMP
 599       /* Unless next switch is -nl, load "loadup.el" first thing.  */
 600       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
 601         Vtop_level = Fcons (intern ("load"),
 602                             Fcons (build_string ("loadup.el"), Qnil));
 603 #endif /* CANNOT_DUMP */
 604     }
 605
 606   initialized = 1;
 607
 608 #ifdef sun
 609   /* sun's localtime() has a bug.  it caches the value of the time
 610      zone rather than looking it up every time.  Since localtime() is
 611      called to bolt the undumping time into the undumped emacs, this
 612      results in localtime() ignoring the TZ environment variable.
 613      This flushes the new TZ value into localtime(). */
 614   tzset();
 615 #endif /* sun */
 616
 617   /* Enter editor command loop.  This never returns.  */
 618   Frecursive_edit ();
 619   /* NOTREACHED */
 620 }
 621 \f
 622 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
 623   "Exit the Emacs job and kill it.\n\
 624 If ARG is an integer, return ARG as the exit program code.\n\
 625 If ARG is a  string, stuff it as keyboard input.\n\n\
 626 The value of `kill-emacs-hook', if not void,\n\
 627 is a list of functions (of no args),\n\
 628 all of which are called before Emacs is actually killed.")
 629   (arg)
 630      Lisp_Object arg;
 631 {
 632   Lisp_Object hook, hook1;
 633   int i;
 634   struct gcpro gcpro1;
 635
 636   GCPRO1 (arg);
 637
 638   if (feof (stdin))
 639     arg = Qt;
 640
 641   if (!NILP (Vrun_hooks) && !noninteractive)
 642     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
 643
 644   UNGCPRO;
 645
 646 /* Is it really necessary to do this deassign
 647    when we are going to exit anyway?  */
 648 /* #ifdef VMS
 649   stop_vms_input ();
 650  #endif  */
 651
 652   shut_down_emacs (0, 0, STRINGP (arg) ? arg : Qnil);
 653
 654   exit ((XTYPE (arg) == Lisp_Int) ? XINT (arg)
 655 #ifdef VMS
 656         : 1
 657 #else
 658         : 0
 659 #endif
 660         );
 661   /* NOTREACHED */
 662 }
 663
 664
 665 /* Perform an orderly shutdown of Emacs.  Autosave any modified
 666    buffers, kill any child processes, clean up the terminal modes (if
 667    we're in the foreground), and other stuff like that.  Don't perform
 668    any redisplay; this may be called when Emacs is shutting down in
 669    the background, or after its X connection has died.
 670
 671    If SIG is a signal number, print a message for it.
 672
 673    This is called by fatal signal handlers, X protocol error handlers,
 674    and Fkill_emacs.  */
 675
 676 void
 677 shut_down_emacs (sig, no_x, stuff)
 678      int sig, no_x;
 679      Lisp_Object stuff;
 680 {
 681   /* If we are controlling the terminal, reset terminal modes */
 682 #ifdef EMACS_HAVE_TTY_PGRP
 683   {
 684 #ifdef USG
 685     int pgrp = getpgrp ();
 686 #else
 687     int pgrp = getpgrp (0);
 688 #endif
 689     int tpgrp;
 690     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
 691         && tpgrp == pgrp)
 692       {
 693         fflush (stdout);
 694         reset_sys_modes ();
 695         if (sig && sig != SIGTERM)
 696           fprintf (stderr, "Fatal error (%d).", sig);
 697       }
 698   }
 699 #else
 700   fflush (stdout);
 701   reset_sys_modes ();
 702 #endif
 703
 704   stuff_buffered_input (stuff);
 705
 706   kill_buffer_processes (Qnil);
 707   Fdo_auto_save (Qt, Qnil);
 708
 709 #ifdef CLASH_DETECTION
 710   unlock_all_files ();
 711 #endif
 712
 713 #ifdef VMS
 714   kill_vms_processes ();
 715 #endif
 716
 717 #ifdef HAVE_X_WINDOWS
 718   if (!noninteractive && EQ (Vwindow_system, intern ("x")) && ! no_x)
 719     Fx_close_current_connection ();
 720 #endif /* HAVE_X_WINDOWS */
 721
 722 #ifdef SIGIO
 723   /* There is a tendency for a SIGIO signal to arrive within exit,
 724      and cause a SIGHUP because the input descriptor is already closed.  */
 725   unrequest_sigio ();
 726   signal (SIGIO, SIG_IGN);
 727 #endif
 728 }
 729
 730
 731 \f
 732 #ifndef CANNOT_DUMP
 733 /* Nothing like this can be implemented on an Apollo.
 734    What a loss!  */
 735
 736 #ifdef HAVE_SHM
 737
 738 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
 739   "Dump current state of Emacs into data file FILENAME.\n\
 740 This function exists on systems that use HAVE_SHM.")
 741   (intoname)
 742      Lisp_Object intoname;
 743 {
 744   extern int my_edata;
 745   Lisp_Object tem;
 746   extern void malloc_warning ();
 747
 748   CHECK_STRING (intoname, 0);
 749   intoname = Fexpand_file_name (intoname, Qnil);
 750
 751   tem = Vpurify_flag;
 752   Vpurify_flag = Qnil;
 753
 754   fflush (stdout);
 755   /* Tell malloc where start of impure now is */
 756   /* Also arrange for warnings when nearly out of space.  */
 757 #ifndef SYSTEM_MALLOC
 758   memory_warnings (&my_edata, malloc_warning);
 759 #endif
 760   map_out_data (XSTRING (intoname)->data);
 761
 762   Vpurify_flag = tem;
 763
 764   return Qnil;
 765 }
 766
 767 #else /* not HAVE_SHM */
 768
 769 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
 770   "Dump current state of Emacs into executable file FILENAME.\n\
 771 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
 772 This is used in the file `loadup.el' when building Emacs.\n\
 773 \n\
 774 Bind `command-line-processed' to nil before dumping,\n\
 775 if you want the dumped Emacs to process its command line\n\
 776 and announce itself normally when it is run.")
 777   (intoname, symname)
 778      Lisp_Object intoname, symname;
 779 {
 780   extern int my_edata;
 781   Lisp_Object tem;
 782   extern void malloc_warning ();
 783
 784   CHECK_STRING (intoname, 0);
 785   intoname = Fexpand_file_name (intoname, Qnil);
 786   if (!NILP (symname))
 787     {
 788       CHECK_STRING (symname, 0);
 789       if (XSTRING (symname)->size)
 790         symname = Fexpand_file_name (symname, Qnil);
 791     }
 792
 793   tem = Vpurify_flag;
 794   Vpurify_flag = Qnil;
 795
 796   fflush (stdout);
 797 #ifdef VMS
 798   mapout_data (XSTRING (intoname)->data);
 799 #else
 800   /* Tell malloc where start of impure now is */
 801   /* Also arrange for warnings when nearly out of space.  */
 802 #ifndef SYSTEM_MALLOC
 803   memory_warnings (&my_edata, malloc_warning);
 804 #endif
 805   unexec (XSTRING (intoname)->data,
 806           !NILP (symname) ? XSTRING (symname)->data : 0, &my_edata, 0, 0);
 807 #endif /* not VMS */
 808
 809   Vpurify_flag = tem;
 810
 811   return Qnil;
 812 }
 813
 814 #endif /* not HAVE_SHM */
 815
 816 #endif /* not CANNOT_DUMP */
 817 \f
 818 #ifndef SEPCHAR
 819 #define SEPCHAR ':'
 820 #endif
 821
 822 Lisp_Object
 823 decode_env_path (evarname, defalt)
 824      char *evarname, *defalt;
 825 {
 826   register char *path, *p;
 827   extern char *index ();
 828
 829   Lisp_Object lpath;
 830
 831   /* It's okay to use getenv here, because this function is only used
 832      to initialize variables when Emacs starts up, and isn't called
 833      after that.  */
 834   if (evarname != 0)
 835     path = (char *) getenv (evarname);
 836   else
 837     path = 0;
 838   if (!path)
 839     path = defalt;
 840   lpath = Qnil;
 841   while (1)
 842     {
 843       p = index (path, SEPCHAR);
 844       if (!p) p = path + strlen (path);
 845       lpath = Fcons (p - path ? make_string (path, p - path) : Qnil,
 846                      lpath);
 847       if (*p)
 848         path = p + 1;
 849       else
 850         break;
 851     }
 852   return Fnreverse (lpath);
 853 }
 854
 855 syms_of_emacs ()
 856 {
 857 #ifndef CANNOT_DUMP
 858 #ifdef HAVE_SHM
 859   defsubr (&Sdump_emacs_data);
 860 #else
 861   defsubr (&Sdump_emacs);
 862 #endif
 863 #endif
 864
 865   defsubr (&Skill_emacs);
 866
 867   defsubr (&Sinvocation_name);
 868
 869   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
 870     "Args passed by shell to Emacs, as a list of strings.");
 871
 872   DEFVAR_LISP ("system-type", &Vsystem_type,
 873     "Value is symbol indicating type of operating system you are using.");
 874   Vsystem_type = intern (SYSTEM_TYPE);
 875
 876   DEFVAR_BOOL ("noninteractive", &noninteractive1,
 877     "Non-nil means Emacs is running without interactive terminal.");
 878
 879   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
 880     "Hook to be run whenever kill-emacs is called.\n\
 881 Since kill-emacs may be invoked when the terminal is disconnected (or\n\
 882 in other similar situations), functions placed on this hook should not\n\
 883 expect to be able to interact with the user.");
 884   Vkill_emacs_hook = Qnil;
 885
 886   DEFVAR_INT ("emacs-priority", &emacs_priority,
 887     "Priority for Emacs to run at.\n\
 888 This value is effective only if set before Emacs is dumped,\n\
 889 and only if the Emacs executable is installed with setuid to permit\n\
 890 it to change priority.  (Emacs sets its uid back to the real uid.)");
 891   emacs_priority = 0;
 892
 893   staticpro (&Vinvocation_name);
 894   Vinvocation_name = Qnil;
 895 }