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