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