src/emacs.c

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