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