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