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