src/emacs.c

   1 /* Fully extensible Emacs, running on Unix, intended for GNU.
   2    Copyright (C) 1985, 86, 87, 93, 94, 95 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, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include <signal.h>
  23 #include <errno.h>
  24
  25 #include <config.h>
  26 #include <stdio.h>
  27
  28 #include <sys/types.h>
  29 #include <sys/file.h>
  30
  31 #ifdef VMS
  32 #include <ssdef.h>
  33 #endif
  34
  35 #ifdef BSD
  36 #include <sys/ioctl.h>
  37 #endif
  38
  39 #include "lisp.h"
  40 #include "commands.h"
  41 #include "intervals.h"
  42
  43 #include "systty.h"
  44 #include "blockinput.h"
  45 #include "syssignal.h"
  46 #include "process.h"
  47
  48 #ifndef O_RDWR
  49 #define O_RDWR 2
  50 #endif
  51
  52 extern void malloc_warning ();
  53 extern void set_time_zone_rule ();
  54 extern char *index ();
  55 extern char *strerror ();
  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 /* The directory name from which Emacs was invoked.  */
  65 Lisp_Object Vinvocation_directory;
  66
  67 /* The directory name in which to find subdirs such as lisp and etc.
  68    nil means get them only from PATH_LOADSEARCH.  */
  69 Lisp_Object Vinstallation_directory;
  70
  71 /* Hook run by `kill-emacs' before it does really anything.  */
  72 Lisp_Object Vkill_emacs_hook;
  73
  74 /* Set nonzero after Emacs has started up the first time.
  75   Prevents reinitialization of the Lisp world and keymaps
  76   on subsequent starts.  */
  77 int initialized;
  78
  79 /* Variable whose value is symbol giving operating system type.  */
  80 Lisp_Object Vsystem_type;
  81
  82 /* Variable whose value is string giving configuration built for.  */
  83 Lisp_Object Vsystem_configuration;
  84
  85 /* Variable whose value is string giving configuration options,
  86    for use when reporting bugs.  */
  87 Lisp_Object Vsystem_configuration_options;
  88
  89 /* If non-zero, emacs should not attempt to use an window-specific code,
  90    but instead should use the virtual terminal under which it was started */
  91 int inhibit_window_system;
  92
  93 /* If nonzero, set Emacs to run at this priority.  This is also used
  94    in child_setup and sys_suspend to make sure subshells run at normal
  95    priority; Those functions have their own extern declaration.  */
  96 int emacs_priority;
  97
  98 /* If non-zero a filter or a sentinel is running.  Tested to save the match
  99    data on the first attempt to change it inside asynchronous code. */
 100 int running_asynch_code;
 101
 102 #ifdef BSD_PGRPS
 103 /* See sysdep.c.  */
 104 extern int inherited_pgroup;
 105 #endif
 106
 107 #ifdef HAVE_X_WINDOWS
 108 /* If non-zero, -d was specified, meaning we're using some window system. */
 109 int display_arg;
 110 #endif
 111
 112 /* An address near the bottom of the stack.
 113    Tells GC how to save a copy of the stack.  */
 114 char *stack_bottom;
 115
 116 #ifdef HAVE_WINDOW_SYSTEM
 117 extern Lisp_Object Vwindow_system;
 118 #endif /* HAVE_WINDOW_SYSTEM */
 119
 120 extern Lisp_Object Vauto_save_list_file_name;
 121
 122 #ifdef USG_SHARED_LIBRARIES
 123 /* If nonzero, this is the place to put the end of the writable segment
 124    at startup.  */
 125
 126 unsigned int bss_end = 0;
 127 #endif
 128
 129 /* Nonzero means running Emacs without interactive terminal.  */
 130
 131 int noninteractive;
 132
 133 /* Value of Lisp variable `noninteractive'.
 134    Normally same as C variable `noninteractive'
 135    but nothing terrible happens if user sets this one.  */
 136
 137 int noninteractive1;
 138
 139 /* Save argv and argc.  */
 140 char **initial_argv;
 141 int initial_argc;
 142
 143 static void sort_args ();
 144 \f
 145 /* Signal code for the fatal signal that was received */
 146 int fatal_error_code;
 147
 148 /* Nonzero if handling a fatal error already */
 149 int fatal_error_in_progress;
 150
 151 /* Handle bus errors, illegal instruction, etc. */
 152 SIGTYPE
 153 fatal_error_signal (sig)
 154      int sig;
 155 {
 156   fatal_error_code = sig;
 157   signal (sig, SIG_DFL);
 158
 159   TOTALLY_UNBLOCK_INPUT;
 160
 161   /* If fatal error occurs in code below, avoid infinite recursion.  */
 162   if (! fatal_error_in_progress)
 163     {
 164       fatal_error_in_progress = 1;
 165
 166       shut_down_emacs (sig, 0, Qnil);
 167     }
 168
 169 #ifdef VMS
 170   LIB$STOP (SS$_ABORT);
 171 #else
 172   /* Signal the same code; this time it will really be fatal.
 173      Remember that since we're in a signal handler, the signal we're
 174      going to send is probably blocked, so we have to unblock it if we
 175      want to really receive it.  */
 176 #ifndef MSDOS
 177   sigunblock (sigmask (fatal_error_code));
 178 #endif
 179   kill (getpid (), fatal_error_code);
 180 #endif /* not VMS */
 181 }
 182
 183 #ifdef SIGDANGER
 184
 185 /* Handler for SIGDANGER.  */
 186 SIGTYPE
 187 memory_warning_signal (sig)
 188      int sig;
 189 {
 190   signal (sig, memory_warning_signal);
 191
 192   malloc_warning ("Operating system warns that virtual memory is running low.\n");
 193
 194   /* It might be unsafe to call do_auto_save now.  */
 195   force_auto_save_soon ();
 196 }
 197 #endif
 198 \f
 199 /* Code for dealing with Lisp access to the Unix command line */
 200
 201 static
 202 init_cmdargs (argc, argv, skip_args)
 203      int argc;
 204      char **argv;
 205      int skip_args;
 206 {
 207   register int i;
 208   Lisp_Object name, dir;
 209
 210   initial_argv = argv;
 211   initial_argc = argc;
 212
 213   Vinvocation_name = Ffile_name_nondirectory (build_string (argv[0]));
 214   Vinvocation_directory = Ffile_name_directory (build_string (argv[0]));
 215   /* If we got no directory in argv[0], search PATH to find where
 216      Emacs actually came from.  */
 217   if (NILP (Vinvocation_directory))
 218     {
 219       Lisp_Object found;
 220       int yes = openp (Vexec_path, Vinvocation_name,
 221                        EXEC_SUFFIXES, &found, 1);
 222       if (yes == 1)
 223         Vinvocation_directory = Ffile_name_directory (found);
 224     }
 225
 226   if (!NILP (Vinvocation_directory)
 227       && NILP (Ffile_name_absolute_p (Vinvocation_directory)))
 228     /* Emacs was started with relative path, like ./emacs  */
 229     Vinvocation_directory = Fexpand_file_name (Vinvocation_directory, Qnil);
 230
 231   Vinstallation_directory = Qnil;
 232
 233   if (!NILP (Vinvocation_directory))
 234     {
 235       dir = Vinvocation_directory;
 236       name = Fexpand_file_name (Vinvocation_name, dir);
 237       while (1)
 238         {
 239           Lisp_Object tem, lib_src_exists;
 240           Lisp_Object etc_exists, info_exists;
 241
 242           /* See if dir contains subdirs for use by Emacs.
 243              Check for the ones that would exist in a build directory,
 244              not including lisp and info.  */
 245           tem = Fexpand_file_name (build_string ("lib-src"), dir);
 246           lib_src_exists = Ffile_exists_p (tem);
 247           if (!NILP (lib_src_exists))
 248             {
 249               tem = Fexpand_file_name (build_string ("etc"), dir);
 250               etc_exists = Ffile_exists_p (tem);
 251               if (!NILP (etc_exists))
 252                 {
 253                   Vinstallation_directory
 254                     = Ffile_name_as_directory (dir);
 255                   break;
 256                 }
 257             }
 258
 259           /* See if dir's parent contains those subdirs.  */
 260           tem = Fexpand_file_name (build_string ("../lib-src"), dir);
 261           lib_src_exists = Ffile_exists_p (tem);
 262           if (!NILP (lib_src_exists))
 263             {
 264               tem = Fexpand_file_name (build_string ("../etc"), dir);
 265               etc_exists = Ffile_exists_p (tem);
 266               if (!NILP (etc_exists))
 267                 {
 268                   tem = Fexpand_file_name (build_string (".."), dir);
 269                   Vinstallation_directory
 270                     = Ffile_name_as_directory (tem);
 271                   break;
 272                 }
 273             }
 274
 275           /* If the Emacs executable is actually a link,
 276              next try the dir that the link points into.  */
 277           tem = Ffile_symlink_p (name);
 278           if (!NILP (tem))
 279             {
 280               name = Fexpand_file_name (tem, dir);
 281               dir = Ffile_name_directory (name);
 282             }
 283           else
 284             break;
 285         }
 286     }
 287
 288   Vcommand_line_args = Qnil;
 289
 290   for (i = argc - 1; i >= 0; i--)
 291     {
 292       if (i == 0 || i > skip_args)
 293         Vcommand_line_args
 294           = Fcons (build_string (argv[i]), Vcommand_line_args);
 295     }
 296 }
 297
 298 DEFUN ("invocation-name", Finvocation_name, Sinvocation_name, 0, 0, 0,
 299   "Return the program name that was used to run Emacs.\n\
 300 Any directory names are omitted.")
 301   ()
 302 {
 303   return Fcopy_sequence (Vinvocation_name);
 304 }
 305
 306 DEFUN ("invocation-directory", Finvocation_directory, Sinvocation_directory,
 307   0, 0, 0,
 308   "Return the directory name in which the Emacs executable was located")
 309   ()
 310 {
 311   return Fcopy_sequence (Vinvocation_directory);
 312 }
 313
 314 \f
 315 #ifdef VMS
 316 #ifdef LINK_CRTL_SHARE
 317 #ifdef SHARABLE_LIB_BUG
 318 extern noshare char **environ;
 319 #endif /* SHARABLE_LIB_BUG */
 320 #endif /* LINK_CRTL_SHARE */
 321 #endif /* VMS */
 322
 323 #ifdef HAVE_TZSET
 324 /* A valid but unlikely value for the TZ environment value.
 325    It is OK (though a bit slower) if the user actually chooses this value.  */
 326 static char dump_tz[] = "UtC0";
 327 #endif
 328
 329 #ifndef ORDINARY_LINK
 330 /* We don't include crtbegin.o and crtend.o in the link,
 331    so these functions and variables might be missed.
 332    Provide dummy definitions to avoid error.
 333    (We don't have any real constructors or destructors.)  */
 334 #ifdef __GNUC__
 335 #ifndef GCC_CTORS_IN_LIBC
 336 __do_global_ctors ()
 337 {}
 338 __do_global_ctors_aux ()
 339 {}
 340 __do_global_dtors ()
 341 {}
 342 /* Linux has a bug in its library; avoid an error.  */
 343 #ifndef LINUX
 344 char * __CTOR_LIST__[2] = { (char *) (-1), 0 };
 345 #endif
 346 char * __DTOR_LIST__[2] = { (char *) (-1), 0 };
 347 #endif /* GCC_CTORS_IN_LIBC */
 348 __main ()
 349 {}
 350 #endif /* __GNUC__ */
 351 #endif /* ORDINARY_LINK */
 352
 353 /* Test whether the next argument in ARGV matches SSTR or a prefix of
 354    LSTR (at least MINLEN characters).  If so, then if VALPTR is non-null
 355    (the argument is supposed to have a value) store in *VALPTR either
 356    the next argument or the portion of this one after the equal sign.
 357    ARGV is read starting at position *SKIPPTR; this index is advanced
 358    by the number of arguments used.
 359
 360    Too bad we can't just use getopt for all of this, but we don't have
 361    enough information to do it right.  */
 362
 363 static int
 364 argmatch (argv, argc, sstr, lstr, minlen, valptr, skipptr)
 365      char **argv;
 366      int argc;
 367      char *sstr;
 368      char *lstr;
 369      int minlen;
 370      char **valptr;
 371      int *skipptr;
 372 {
 373   char *p;
 374   int arglen;
 375   char *arg;
 376
 377   /* Don't access argv[argc]; give up in advance.  */
 378   if (argc <= *skipptr + 1)
 379     return 0;
 380
 381   arg = argv[*skipptr+1];
 382   if (arg == NULL)
 383     return 0;
 384   if (strcmp (arg, sstr) == 0)
 385     {
 386       if (valptr != NULL)
 387         {
 388           *valptr = argv[*skipptr+2];
 389           *skipptr += 2;
 390         }
 391       else
 392         *skipptr += 1;
 393       return 1;
 394     }
 395   arglen = (valptr != NULL && (p = index (arg, '=')) != NULL
 396             ? p - arg : strlen (arg));
 397   if (lstr == 0 || arglen < minlen || strncmp (arg, lstr, arglen) != 0)
 398     return 0;
 399   else if (valptr == NULL)
 400     {
 401       *skipptr += 1;
 402       return 1;
 403     }
 404   else if (p != NULL)
 405     {
 406       *valptr = p+1;
 407       *skipptr += 1;
 408       return 1;
 409     }
 410   else if (argv[*skipptr+2] != NULL)
 411     {
 412       *valptr = argv[*skipptr+2];
 413       *skipptr += 2;
 414       return 1;
 415     }
 416   else
 417     {
 418       return 0;
 419     }
 420 }
 421
 422 /* ARGSUSED */
 423 main (argc, argv, envp)
 424      int argc;
 425      char **argv;
 426      char **envp;
 427 {
 428   char stack_bottom_variable;
 429   int skip_args = 0;
 430   extern int errno;
 431   extern sys_nerr;
 432
 433 #ifdef LINUX_SBRK_BUG
 434   __sbrk (1);
 435 #endif
 436
 437   sort_args (argc, argv);
 438
 439   if (argmatch (argv, argc, "-version", "--version", 3, NULL, &skip_args))
 440     {
 441       Lisp_Object tem;
 442       tem = Fsymbol_value (intern ("emacs-version"));
 443       if (!STRINGP (tem))
 444         {
 445           fprintf (stderr, "Invalid value of `emacs-version'\n");
 446           exit (1);
 447         }
 448       else
 449         {
 450           printf ("GNU Emacs %s\n", XSTRING (tem)->data);
 451           exit (0);
 452         }
 453     }
 454
 455 /* Map in shared memory, if we are using that.  */
 456 #ifdef HAVE_SHM
 457   if (argmatch (argv, argc, "-nl", "--no-shared-memory", 6, NULL, &skip_args))
 458     {
 459       map_in_data (0);
 460       /* The shared memory was just restored, which clobbered this.  */
 461       skip_args = 1;
 462     }
 463   else
 464     {
 465       map_in_data (1);
 466       /* The shared memory was just restored, which clobbered this.  */
 467       skip_args = 0;
 468     }
 469 #endif
 470
 471 #ifdef NeXT
 472   {
 473     extern int malloc_cookie;
 474     /* This helps out unexnext.c.  */
 475     if (initialized)
 476       if (malloc_jumpstart (malloc_cookie) != 0)
 477         printf ("malloc jumpstart failed!\n");
 478   }
 479 #endif /* NeXT */
 480
 481 #ifdef VMS
 482   /* If -map specified, map the data file in */
 483   {
 484     char *file;
 485     if (argmatch (argv, argc, "-map", "--map-data", 3, &mapin_file, &skip_args))
 486       mapin_data (file);
 487   }
 488
 489 #ifdef LINK_CRTL_SHARE
 490 #ifdef SHARABLE_LIB_BUG
 491   /* Bletcherous shared libraries! */
 492   if (!stdin)
 493     stdin = fdopen (0, "r");
 494   if (!stdout)
 495     stdout = fdopen (1, "w");
 496   if (!stderr)
 497     stderr = fdopen (2, "w");
 498   if (!environ)
 499     environ = envp;
 500 #endif /* SHARABLE_LIB_BUG */
 501 #endif /* LINK_CRTL_SHARE */
 502 #endif /* VMS */
 503
 504   /* Record (approximately) where the stack begins.  */
 505   stack_bottom = &stack_bottom_variable;
 506
 507 #ifdef RUN_TIME_REMAP
 508   if (initialized)
 509     run_time_remap (argv[0]);
 510 #endif
 511
 512 #ifdef USG_SHARED_LIBRARIES
 513   if (bss_end)
 514     brk ((void *)bss_end);
 515 #endif
 516
 517   clearerr (stdin);
 518
 519 #ifndef SYSTEM_MALLOC
 520   if (! initialized)
 521     {
 522       /* Arrange to get warning messages as memory fills up.  */
 523       memory_warnings (0, malloc_warning);
 524
 525       /* Arrange to disable interrupt input while malloc and friends are
 526          running.  */
 527       uninterrupt_malloc ();
 528     }
 529 #endif  /* not SYSTEM_MALLOC */
 530
 531 #ifdef MSDOS
 532   /* We do all file input/output as binary files.  When we need to translate
 533      newlines, we do that manually.  */
 534   _fmode = O_BINARY;
 535
 536 #if __DJGPP__ >= 2
 537   if (!isatty (fileno (stdin)))
 538     setmode (fileno (stdin), O_BINARY);
 539   if (!isatty (fileno (stdout)))
 540     {
 541       fflush (stdout);
 542       setmode (fileno (stdout), O_BINARY);
 543     }
 544 #else  /* not __DJGPP__ >= 2 */
 545   (stdin)->_flag &= ~_IOTEXT;
 546   (stdout)->_flag &= ~_IOTEXT;
 547   (stderr)->_flag &= ~_IOTEXT;
 548 #endif /* not __DJGPP__ >= 2 */
 549 #endif /* MSDOS */
 550
 551 #ifdef SET_EMACS_PRIORITY
 552   if (emacs_priority)
 553     nice (emacs_priority);
 554   setuid (getuid ());
 555 #endif /* SET_EMACS_PRIORITY */
 556
 557 #ifdef EXTRA_INITIALIZE
 558   EXTRA_INITIALIZE;
 559 #endif
 560
 561   inhibit_window_system = 0;
 562
 563   /* Handle the -t switch, which specifies filename to use as terminal */
 564   {
 565     char *term;
 566     if (argmatch (argv, argc, "-t", "--terminal", 4, &term, &skip_args))
 567       {
 568         int result;
 569         close (0);
 570         close (1);
 571         result = open (term, O_RDWR, 2 );
 572         if (result < 0)
 573           {
 574             char *errstring = strerror (errno);
 575             fprintf (stderr, "emacs: %s: %s\n", term, errstring);
 576             exit (1);
 577           }
 578         dup (0);
 579         if (! isatty (0))
 580           {
 581             fprintf (stderr, "emacs: %s: not a tty\n", term);
 582             exit (1);
 583           }
 584         fprintf (stderr, "Using %s\n", term);
 585 #ifdef HAVE_WINDOW_SYSTEM
 586         inhibit_window_system = 1; /* -t => -nw */
 587 #endif
 588       }
 589   }
 590   if (argmatch (argv, argc, "-nw", "--no-windows", 6, NULL, &skip_args))
 591     inhibit_window_system = 1;
 592
 593   /* Handle the -batch switch, which means don't do interactive display.  */
 594   noninteractive = 0;
 595   if (argmatch (argv, argc, "-batch", "--batch", 5, NULL, &skip_args))
 596     noninteractive = 1;
 597
 598   /* Handle the --help option, which gives a usage message..  */
 599   if (argmatch (argv, argc, "-help", "--help", 3, NULL, &skip_args))
 600     {
 601       printf ("\
 602 Usage: %s [-t term] [--terminal term]  [-nw] [--no-windows]  [--batch]\n\
 603       [-q] [--no-init-file]  [-u user] [--user user]  [--debug-init]\n\
 604       [--version] [--no-site-file]\n\
 605       [-f func] [--funcall func]  [-l file] [--load file]  [--insert file]\n\
 606       [+linenum] file-to-visit  [--kill]\n\
 607 Report bugs to bug-gnu-emacs@prep.ai.mit.edu.  First, please see\n\
 608 the Bugs section of the Emacs manual or the file BUGS.", argv[0]);
 609       exit (0);
 610     }
 611
 612 #ifdef HAVE_X_WINDOWS
 613   /* Stupid kludge to catch command-line display spec.  We can't
 614      handle this argument entirely in window system dependent code
 615      because we don't even know which window system dependent code
 616      to run until we've recognized this argument.  */
 617   {
 618     char *displayname = 0;
 619     int i;
 620     int count_before = skip_args;
 621
 622     if (argmatch (argv, argc, "-d", "--display", 3, &displayname, &skip_args))
 623       display_arg = 1;
 624     else if (argmatch (argv, argc, "-display", 0, 3, &displayname, &skip_args))
 625       display_arg = 1;
 626
 627     /* If we have the form --display=NAME,
 628        convert it into  -d name.
 629        This requires inserting a new element into argv.  */
 630     if (displayname != 0 && skip_args - count_before == 1)
 631       {
 632         char **new = (char **) xmalloc (sizeof (char *) * (argc + 2));
 633         int j;
 634
 635         for (j = 0; j < count_before + 1; j++)
 636           new[j] = argv[j];
 637         new[count_before + 1] = "-d";
 638         new[count_before + 2] = displayname;
 639         for (j = count_before + 2; j <argc; j++)
 640           new[j + 1] = argv[j];
 641         argv = new;
 642         argc++;
 643       }
 644     /* Change --display to -d, when its arg is separate.  */
 645     else if (displayname != 0 && skip_args > count_before
 646              && argv[count_before + 1][1] == '-')
 647       argv[count_before + 1] = "-d";
 648
 649     /* Don't actually discard this arg.  */
 650     skip_args = count_before;
 651   }
 652 #endif
 653
 654   if (! noninteractive)
 655     {
 656 #ifdef BSD_PGRPS
 657       if (initialized)
 658         {
 659           inherited_pgroup = EMACS_GETPGRP (0);
 660           setpgrp (0, getpid ());
 661         }
 662 #else
 663 #if defined (USG5) && defined (INTERRUPT_INPUT)
 664       setpgrp ();
 665 #endif
 666 #endif
 667     }
 668
 669 #ifdef POSIX_SIGNALS
 670   init_signals ();
 671 #endif
 672
 673   /* Don't catch SIGHUP if dumping.  */
 674   if (1
 675 #ifndef CANNOT_DUMP
 676       && initialized
 677 #endif
 678       )
 679     {
 680       sigblock (sigmask (SIGHUP));
 681       /* In --batch mode, don't catch SIGHUP if already ignored.
 682          That makes nohup work.  */
 683       if (! noninteractive
 684           || signal (SIGHUP, SIG_IGN) != SIG_IGN)
 685         signal (SIGHUP, fatal_error_signal);
 686       sigunblock (sigmask (SIGHUP));
 687     }
 688
 689   if (
 690 #ifndef CANNOT_DUMP
 691       ! noninteractive || initialized
 692 #else
 693       1
 694 #endif
 695       )
 696     {
 697       /* Don't catch these signals in batch mode if dumping.
 698          On some machines, this sets static data that would make
 699          signal fail to work right when the dumped Emacs is run.  */
 700       signal (SIGQUIT, fatal_error_signal);
 701       signal (SIGILL, fatal_error_signal);
 702       signal (SIGTRAP, fatal_error_signal);
 703 #ifdef SIGABRT
 704       signal (SIGABRT, fatal_error_signal);
 705 #endif
 706 #ifdef SIGHWE
 707       signal (SIGHWE, fatal_error_signal);
 708 #endif
 709 #ifdef SIGPRE
 710       signal (SIGPRE, fatal_error_signal);
 711 #endif
 712 #ifdef SIGORE
 713       signal (SIGORE, fatal_error_signal);
 714 #endif
 715 #ifdef SIGUME
 716       signal (SIGUME, fatal_error_signal);
 717 #endif
 718 #ifdef SIGDLK
 719       signal (SIGDLK, fatal_error_signal);
 720 #endif
 721 #ifdef SIGCPULIM
 722       signal (SIGCPULIM, fatal_error_signal);
 723 #endif
 724 #ifdef SIGIOT
 725       /* This is missing on some systems - OS/2, for example.  */
 726       signal (SIGIOT, fatal_error_signal);
 727 #endif
 728 #ifdef SIGEMT
 729       signal (SIGEMT, fatal_error_signal);
 730 #endif
 731       signal (SIGFPE, fatal_error_signal);
 732 #ifdef SIGBUS
 733       signal (SIGBUS, fatal_error_signal);
 734 #endif
 735       signal (SIGSEGV, fatal_error_signal);
 736 #ifdef SIGSYS
 737       signal (SIGSYS, fatal_error_signal);
 738 #endif
 739       signal (SIGTERM, fatal_error_signal);
 740 #ifdef SIGXCPU
 741       signal (SIGXCPU, fatal_error_signal);
 742 #endif
 743 #ifdef SIGXFSZ
 744       signal (SIGXFSZ, fatal_error_signal);
 745 #endif /* SIGXFSZ */
 746
 747 #ifdef SIGDANGER
 748       /* This just means available memory is getting low.  */
 749       signal (SIGDANGER, memory_warning_signal);
 750 #endif
 751
 752 #ifdef AIX
 753 /* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU.  */
 754       signal (SIGXCPU, fatal_error_signal);
 755 #ifndef _I386
 756       signal (SIGIOINT, fatal_error_signal);
 757 #endif
 758       signal (SIGGRANT, fatal_error_signal);
 759       signal (SIGRETRACT, fatal_error_signal);
 760       signal (SIGSOUND, fatal_error_signal);
 761       signal (SIGMSG, fatal_error_signal);
 762 #endif /* AIX */
 763     }
 764
 765   noninteractive1 = noninteractive;
 766
 767 /* Perform basic initializations (not merely interning symbols) */
 768
 769   if (!initialized)
 770     {
 771       init_alloc_once ();
 772       init_obarray ();
 773       init_eval_once ();
 774       init_syntax_once ();      /* Create standard syntax table.  */
 775                       /* Must be done before init_buffer */
 776       init_casetab_once ();
 777       init_buffer_once ();      /* Create buffer table and some buffers */
 778       init_minibuf_once ();     /* Create list of minibuffers */
 779                               /* Must precede init_window_once */
 780       init_window_once ();      /* Init the window system */
 781     }
 782
 783   init_alloc ();
 784   init_eval ();
 785   init_data ();
 786   running_asynch_code = 0;
 787
 788 #ifdef MSDOS
 789   /* Call early 'cause init_environment needs it.  */
 790   init_dosfns ();
 791   /* Set defaults for several environment variables.  */
 792   if (initialized)
 793     init_environment (argc, argv, skip_args);
 794   else
 795     tzset ();
 796 #endif /* MSDOS */
 797
 798 #ifdef WINDOWSNT
 799   /* Initialize environment from registry settings.  */
 800   init_environment ();
 801   init_ntproc ();       /* must precede init_editfns */
 802 #endif
 803
 804   /* egetenv is a pretty low-level facility, which may get called in
 805      many circumstances; it seems flimsy to put off initializing it
 806      until calling init_callproc.  */
 807   set_process_environment ();
 808   /* AIX crashes are reported in system versions 3.2.3 and 3.2.4
 809      if this is not done.  Do it after set_process_environment so that we
 810      don't pollute Vprocess_environment.  */
 811 #ifdef AIX
 812   putenv ("LANG=C");
 813 #endif
 814
 815   init_buffer ();       /* Init default directory of main buffer */
 816
 817   init_callproc_1 ();   /* Must precede init_cmdargs and init_sys_modes.  */
 818   init_cmdargs (argc, argv, skip_args); /* Must precede init_lread.  */
 819   init_callproc ();     /* Must follow init_cmdargs but not init_sys_modes.  */
 820   init_lread ();
 821
 822   if (!noninteractive)
 823     {
 824 #ifdef VMS
 825       init_vms_input ();/* init_display calls get_frame_size, that needs this */
 826 #endif /* VMS */
 827       init_display ();  /* Determine terminal type.  init_sys_modes uses results */
 828     }
 829   init_keyboard ();     /* This too must precede init_sys_modes */
 830 #ifdef VMS
 831   init_vmsproc ();      /* And this too. */
 832 #endif /* VMS */
 833   init_sys_modes ();    /* Init system terminal modes (RAW or CBREAK, etc.) */
 834   init_xdisp ();
 835   init_macros ();
 836   init_editfns ();
 837 #ifdef LISP_FLOAT_TYPE
 838   init_floatfns ();
 839 #endif
 840 #ifdef VMS
 841   init_vmsfns ();
 842 #endif /* VMS */
 843   init_process ();
 844 #ifdef CLASH_DETECTION
 845   init_filelock ();
 846 #endif /* CLASH_DETECTION */
 847
 848 /* Intern the names of all standard functions and variables; define standard keys */
 849
 850   if (!initialized)
 851     {
 852       /* The basic levels of Lisp must come first */
 853       /* And data must come first of all
 854          for the sake of symbols like error-message */
 855       syms_of_data ();
 856       syms_of_alloc ();
 857       syms_of_lread ();
 858       syms_of_print ();
 859       syms_of_eval ();
 860       syms_of_fns ();
 861       syms_of_floatfns ();
 862
 863       syms_of_abbrev ();
 864       syms_of_buffer ();
 865       syms_of_bytecode ();
 866       syms_of_callint ();
 867       syms_of_casefiddle ();
 868       syms_of_casetab ();
 869       syms_of_callproc ();
 870       syms_of_cmds ();
 871 #ifndef NO_DIR_LIBRARY
 872       syms_of_dired ();
 873 #endif /* not NO_DIR_LIBRARY */
 874       syms_of_display ();
 875       syms_of_doc ();
 876       syms_of_editfns ();
 877       syms_of_emacs ();
 878       syms_of_fileio ();
 879 #ifdef CLASH_DETECTION
 880       syms_of_filelock ();
 881 #endif /* CLASH_DETECTION */
 882       syms_of_indent ();
 883       syms_of_keyboard ();
 884       syms_of_keymap ();
 885       syms_of_macros ();
 886       syms_of_marker ();
 887       syms_of_minibuf ();
 888       syms_of_mocklisp ();
 889       syms_of_process ();
 890       syms_of_search ();
 891       syms_of_frame ();
 892       syms_of_syntax ();
 893       syms_of_term ();
 894       syms_of_undo ();
 895
 896       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
 897       syms_of_textprop ();
 898 #ifdef VMS
 899       syms_of_vmsproc ();
 900 #endif /* VMS */
 901 #ifdef WINDOWSNT
 902       syms_of_ntproc ();
 903 #endif /* WINDOWSNT */
 904       syms_of_window ();
 905       syms_of_xdisp ();
 906 #ifdef HAVE_X_WINDOWS
 907       syms_of_xterm ();
 908       syms_of_xfns ();
 909       syms_of_xfaces ();
 910 #ifdef HAVE_X11
 911       syms_of_xselect ();
 912 #endif
 913 #endif /* HAVE_X_WINDOWS */
 914
 915 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
 916       syms_of_xfaces ();
 917 #endif
 918
 919 #ifndef HAVE_NTGUI
 920       syms_of_xmenu ();
 921 #endif
 922
 923 #ifdef HAVE_NTGUI
 924       syms_of_win32term ();
 925       syms_of_win32fns ();
 926       syms_of_win32faces ();
 927       syms_of_win32select ();
 928       syms_of_win32menu ();
 929 #endif /* HAVE_NTGUI */
 930
 931 #ifdef SYMS_SYSTEM
 932       SYMS_SYSTEM;
 933 #endif
 934
 935 #ifdef SYMS_MACHINE
 936       SYMS_MACHINE;
 937 #endif
 938
 939       keys_of_casefiddle ();
 940       keys_of_cmds ();
 941       keys_of_buffer ();
 942       keys_of_keyboard ();
 943       keys_of_keymap ();
 944       keys_of_macros ();
 945       keys_of_minibuf ();
 946       keys_of_window ();
 947       keys_of_frame ();
 948     }
 949
 950   if (!initialized)
 951     {
 952       char *file;
 953       /* Handle -l loadup-and-dump, args passed by Makefile. */
 954       if (argmatch (argv, argc, "-l", "--load", 3, &file, &skip_args))
 955         Vtop_level = Fcons (intern ("load"),
 956                             Fcons (build_string (file), Qnil));
 957 #ifdef CANNOT_DUMP
 958       /* Unless next switch is -nl, load "loadup.el" first thing.  */
 959       if (!argmatch (argv, argc, "-nl", "--no-loadup", 6, NULL, &skip_args))
 960         Vtop_level = Fcons (intern ("load"),
 961                             Fcons (build_string ("loadup.el"), Qnil));
 962 #endif /* CANNOT_DUMP */
 963     }
 964
 965   if (initialized)
 966     {
 967       /* Erase any pre-dump messages in the message log, to avoid confusion */
 968       Lisp_Object old_log_max;
 969       old_log_max = Vmessage_log_max;
 970       XSETFASTINT (Vmessage_log_max, 0);
 971       message_dolog ("", 0, 1);
 972       Vmessage_log_max = old_log_max;
 973
 974 #ifdef HAVE_TZSET
 975       {
 976         /* If the execution TZ happens to be the same as the dump TZ,
 977            change it to some other value and then change it back,
 978            to force the underlying implementation to reload the TZ info.
 979            This is needed on implementations that load TZ info from files,
 980            since the TZ file contents may differ between dump and execution.  */
 981         char *tz = getenv ("TZ");
 982         if (tz && !strcmp (tz, dump_tz))
 983           {
 984             ++*tz;
 985             tzset ();
 986             --*tz;
 987           }
 988       }
 989 #endif
 990     }
 991
 992   initialized = 1;
 993
 994 #ifdef LOCALTIME_CACHE
 995   /* Some versions of localtime have a bug.  They cache the value of the time
 996      zone rather than looking it up every time.  Since localtime() is
 997      called to bolt the undumping time into the undumped emacs, this
 998      results in localtime ignoring the TZ environment variable.
 999      This flushes the new TZ value into localtime. */
1000   tzset ();
1001 #endif /* defined (LOCALTIME_CACHE) */
1002
1003   /* Enter editor command loop.  This never returns.  */
1004   Frecursive_edit ();
1005   /* NOTREACHED */
1006 }
1007 \f
1008 /* Sort the args so we can find the most important ones
1009    at the beginning of argv.  */
1010
1011 /* First, here's a table of all the standard options.  */
1012
1013 struct standard_args
1014 {
1015   char *name;
1016   char *longname;
1017   int priority;
1018   int nargs;
1019 };
1020
1021 struct standard_args standard_args[] =
1022 {
1023   { "-version", "--version", 110, 0 },
1024   { "-help", "--help", 110, 0 },
1025   { "-nl", "--no-shared-memory", 100, 0 },
1026 #ifdef VMS
1027   { "-map", "--map-data", 100, 0 },
1028 #endif
1029   { "-t", "--terminal", 90, 1 },
1030   { "-d", "--display", 80, 1 },
1031   { "-display", 0, 80, 1 },
1032   { "-nw", "--no-windows", 70, 0 },
1033   { "-batch", "--batch", 60, 0 },
1034   { "-q", "--no-init-file", 50, 0 },
1035   { "-no-init-file", 0, 50, 0 },
1036   { "-no-site-file", "--no-site-file", 40, 0 },
1037   { "-u", "--user", 30, 1 },
1038   { "-user", 0, 30, 1 },
1039   { "-debug-init", "--debug-init", 20, 0 },
1040   { "-i", "--icon-type", 15, 0 },
1041   { "-itype", 0, 15, 0 },
1042   { "-iconic", "--iconic", 15, 0 },
1043   { "-bg", "--background-color", 10, 1 },
1044   { "-background", 0, 10, 1 },
1045   { "-fg", "--foreground-color", 10, 1 },
1046   { "-foreground", 0, 10, 1 },
1047   { "-bd", "--border-color", 10, 1 },
1048   { "-bw", "--border-width", 10, 1 },
1049   { "-ib", "--internal-border", 10, 1 },
1050   { "-ms", "--mouse-color", 10, 1 },
1051   { "-cr", "--cursor-color", 10, 1 },
1052   { "-fn", "--font", 10, 1 },
1053   { "-font", 0, 10, 1 },
1054   { "-g", "--geometry", 10, 1 },
1055   { "-geometry", 0, 10, 1 },
1056   { "-T", "--title", 10, 1 },
1057   { "-title", 0, 10, 1 },
1058   { "-name", "--name", 10, 1 },
1059   { "-xrm", "--xrm", 10, 1 },
1060   { "-r", "--reverse-video", 5, 0 },
1061   { "-rv", 0, 5, 0 },
1062   { "-reverse", 0, 5, 0 },
1063   { "-hb", "--horizontal-scroll-bars", 5, 0 },
1064   { "-vb", "--vertical-scroll-bars", 5, 0 },
1065   /* These have the same priority as ordinary file name args,
1066      so they are not reordered with respect to those.  */
1067   { "-L", "--directory", 0, 1 },
1068   { "-directory", 0, 0, 1 },
1069   { "-l", "--load", 0, 1 },
1070   { "-load", 0, 0, 1 },
1071   { "-f", "--funcall", 0, 1 },
1072   { "-funcall", 0, 0, 1 },
1073   { "-eval", "--eval", 0, 1 },
1074   { "-insert", "--insert", 0, 1 },
1075   /* This should be processed after ordinary file name args and the like.  */
1076   { "-kill", "--kill", -10, 0 },
1077 };
1078
1079 /* Reorder the elements of ARGV (assumed to have ARGC elements)
1080    so that the highest priority ones come first.
1081    Do not change the order of elements of equal priority.
1082    If an option takes an argument, keep it and its argument together.  */
1083
1084 static void
1085 sort_args (argc, argv)
1086      int argc;
1087      char **argv;
1088 {
1089   char **new = (char **) xmalloc (sizeof (char *) * argc);
1090   /* For each element of argv,
1091      the corresponding element of options is:
1092      0 for an option that takes no arguments,
1093      1 for an option that takes one argument, etc.
1094      -1 for an ordinary non-option argument.  */
1095   int *options = (int *) xmalloc (sizeof (int) * argc);
1096   int *priority = (int *) xmalloc (sizeof (int) * argc);
1097   int to = 1;
1098   int from;
1099   int i;
1100
1101   /* Categorize all the options,
1102      and figure out which argv elts are option arguments.  */
1103   for (from = 1; from < argc; from++)
1104     {
1105       options[from] = -1;
1106       priority[from] = 0;
1107       if (argv[from][0] == '-')
1108         {
1109           int match, thislen;
1110           char *equals;
1111
1112           /* Look for a match with a known old-fashioned option.  */
1113           for (i = 0; i < sizeof (standard_args) / sizeof (standard_args[0]); i++)
1114             if (!strcmp (argv[from], standard_args[i].name))
1115               {
1116                 options[from] = standard_args[i].nargs;
1117                 priority[from] = standard_args[i].priority;
1118                 if (from + standard_args[i].nargs >= argc)
1119                   fatal ("Option `%s' requires an argument\n", argv[from]);
1120                 from += standard_args[i].nargs;
1121                 goto done;
1122               }
1123
1124           /* Look for a match with a known long option.
1125              MATCH is -1 if no match so far, -2 if two or more matches so far,
1126              >= 0 (the table index of the match) if just one match so far.  */
1127           if (argv[from][1] == '-')
1128             {
1129               match = -1;
1130               thislen = strlen (argv[from]);
1131               equals = index (argv[from], '=');
1132               if (equals != 0)
1133                 thislen = equals - argv[from];
1134
1135               for (i = 0;
1136                    i < sizeof (standard_args) / sizeof (standard_args[0]); i++)
1137                 if (standard_args[i].longname
1138                     && !strncmp (argv[from], standard_args[i].longname,
1139                                  thislen))
1140                   {
1141                     if (match == -1)
1142                       match = i;
1143                     else
1144                       match = -2;
1145                   }
1146
1147               /* If we found exactly one match, use that.  */
1148               if (match >= 0)
1149                 {
1150                   options[from] = standard_args[match].nargs;
1151                   priority[from] = standard_args[match].priority;
1152                   /* If --OPTION=VALUE syntax is used,
1153                      this option uses just one argv element.  */
1154                   if (equals != 0)
1155                     options[from] = 0;
1156                   if (from + options[from] >= argc)
1157                     fatal ("Option `%s' requires an argument\n", argv[from]);
1158                   from += options[from];
1159                 }
1160             }
1161         done: ;
1162         }
1163     }
1164
1165   /* Copy the arguments, in order of decreasing priority, to NEW.  */
1166   new[0] = argv[0];
1167   while (to < argc)
1168     {
1169       int best = -1;
1170       int best_priority = -9999;
1171
1172       /* Find the highest priority remaining option.
1173          If several have equal priority, take the first of them.  */
1174       for (from = 1; from < argc; from++)
1175         {
1176           if (argv[from] != 0 && priority[from] > best_priority)
1177             {
1178               best_priority = priority[from];
1179               best = from;
1180             }
1181           /* Skip option arguments--they are tied to the options.  */
1182           if (options[from] > 0)
1183             from += options[from];
1184         }
1185
1186       if (best < 0)
1187         abort ();
1188
1189       /* Copy the highest priority remaining option, with its args, to NEW.  */
1190       new[to++] = argv[best];
1191       for (i = 0; i < options[best]; i++)
1192         new[to++] = argv[best + i + 1];
1193
1194       /* Clear out this option in ARGV.  */
1195       argv[best] = 0;
1196       for (i = 0; i < options[best]; i++)
1197         argv[best + i + 1] = 0;
1198     }
1199
1200   bcopy (new, argv, sizeof (char *) * argc);
1201 }
1202 \f
1203 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
1204   "Exit the Emacs job and kill it.\n\
1205 If ARG is an integer, return ARG as the exit program code.\n\
1206 If ARG is a  string, stuff it as keyboard input.\n\n\
1207 The value of `kill-emacs-hook', if not void,\n\
1208 is a list of functions (of no args),\n\
1209 all of which are called before Emacs is actually killed.")
1210   (arg)
1211      Lisp_Object arg;
1212 {
1213   Lisp_Object hook, hook1;
1214   int i;
1215   struct gcpro gcpro1;
1216
1217   GCPRO1 (arg);
1218
1219   if (feof (stdin))
1220     arg = Qt;
1221
1222   if (!NILP (Vrun_hooks) && !noninteractive)
1223     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
1224
1225   UNGCPRO;
1226
1227 /* Is it really necessary to do this deassign
1228    when we are going to exit anyway?  */
1229 /* #ifdef VMS
1230   stop_vms_input ();
1231  #endif  */
1232
1233   shut_down_emacs (0, 0, STRINGP (arg) ? arg : Qnil);
1234
1235   /* If we have an auto-save list file,
1236      kill it because we are exiting Emacs deliberately (not crashing).
1237      Do it after shut_down_emacs, which does an auto-save.  */
1238   if (STRINGP (Vauto_save_list_file_name))
1239     unlink (XSTRING (Vauto_save_list_file_name)->data);
1240
1241   exit (INTEGERP (arg) ? XINT (arg)
1242 #ifdef VMS
1243         : 1
1244 #else
1245         : 0
1246 #endif
1247         );
1248   /* NOTREACHED */
1249 }
1250
1251
1252 /* Perform an orderly shutdown of Emacs.  Autosave any modified
1253    buffers, kill any child processes, clean up the terminal modes (if
1254    we're in the foreground), and other stuff like that.  Don't perform
1255    any redisplay; this may be called when Emacs is shutting down in
1256    the background, or after its X connection has died.
1257
1258    If SIG is a signal number, print a message for it.
1259
1260    This is called by fatal signal handlers, X protocol error handlers,
1261    and Fkill_emacs.  */
1262
1263 void
1264 shut_down_emacs (sig, no_x, stuff)
1265      int sig, no_x;
1266      Lisp_Object stuff;
1267 {
1268   /* Prevent running of hooks from now on.  */
1269   Vrun_hooks = Qnil;
1270
1271   /* If we are controlling the terminal, reset terminal modes */
1272 #ifdef EMACS_HAVE_TTY_PGRP
1273   {
1274     int pgrp = EMACS_GETPGRP (0);
1275
1276     int tpgrp;
1277     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
1278         && tpgrp == pgrp)
1279       {
1280         fflush (stdout);
1281         reset_sys_modes ();
1282         if (sig && sig != SIGTERM)
1283           fprintf (stderr, "Fatal error (%d).", sig);
1284       }
1285   }
1286 #else
1287   fflush (stdout);
1288   reset_sys_modes ();
1289 #endif
1290
1291   stuff_buffered_input (stuff);
1292
1293   kill_buffer_processes (Qnil);
1294   Fdo_auto_save (Qt, Qnil);
1295
1296 #ifdef CLASH_DETECTION
1297   unlock_all_files ();
1298 #endif
1299
1300 #ifdef VMS
1301   kill_vms_processes ();
1302 #endif
1303
1304 #if 0 /* This triggers a bug in XCloseDisplay and is not needed.  */
1305 #ifdef HAVE_X_WINDOWS
1306   /* It's not safe to call intern here.  Maybe we are crashing.  */
1307   if (!noninteractive && SYMBOLP (Vwindow_system)
1308       && XSYMBOL (Vwindow_system)->name->size == 1
1309       && XSYMBOL (Vwindow_system)->name->data[0] == 'x'
1310       && ! no_x)
1311     Fx_close_current_connection ();
1312 #endif /* HAVE_X_WINDOWS */
1313 #endif
1314
1315 #ifdef SIGIO
1316   /* There is a tendency for a SIGIO signal to arrive within exit,
1317      and cause a SIGHUP because the input descriptor is already closed.  */
1318   unrequest_sigio ();
1319   signal (SIGIO, SIG_IGN);
1320 #endif
1321
1322 #ifdef WINDOWSNT
1323   term_ntproc ();
1324 #endif
1325 }
1326
1327
1328 \f
1329 #ifndef CANNOT_DUMP
1330
1331 #ifdef HAVE_SHM
1332
1333 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
1334   "Dump current state of Emacs into data file FILENAME.\n\
1335 This function exists on systems that use HAVE_SHM.")
1336   (filename)
1337      Lisp_Object filename;
1338 {
1339   extern char my_edata[];
1340   Lisp_Object tem;
1341
1342   CHECK_STRING (filename, 0);
1343   filename = Fexpand_file_name (filename, Qnil);
1344
1345   tem = Vpurify_flag;
1346   Vpurify_flag = Qnil;
1347
1348   fflush (stdout);
1349   /* Tell malloc where start of impure now is */
1350   /* Also arrange for warnings when nearly out of space.  */
1351 #ifndef SYSTEM_MALLOC
1352   memory_warnings (my_edata, malloc_warning);
1353 #endif
1354   map_out_data (XSTRING (filename)->data);
1355
1356   Vpurify_flag = tem;
1357
1358   return Qnil;
1359 }
1360
1361 #else /* not HAVE_SHM */
1362
1363 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
1364   "Dump current state of Emacs into executable file FILENAME.\n\
1365 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
1366 This is used in the file `loadup.el' when building Emacs.\n\
1367 \n\
1368 Bind `command-line-processed' to nil before dumping,\n\
1369 if you want the dumped Emacs to process its command line\n\
1370 and announce itself normally when it is run.")
1371   (filename, symfile)
1372      Lisp_Object filename, symfile;
1373 {
1374   extern char my_edata[];
1375   Lisp_Object tem;
1376
1377   CHECK_STRING (filename, 0);
1378   filename = Fexpand_file_name (filename, Qnil);
1379   if (!NILP (symfile))
1380     {
1381       CHECK_STRING (symfile, 0);
1382       if (XSTRING (symfile)->size)
1383         symfile = Fexpand_file_name (symfile, Qnil);
1384     }
1385
1386   tem = Vpurify_flag;
1387   Vpurify_flag = Qnil;
1388
1389 #ifdef HAVE_TZSET
1390   set_time_zone_rule (dump_tz);
1391 #ifndef LOCALTIME_CACHE
1392   /* Force a tz reload, since set_time_zone_rule doesn't.  */
1393   tzset ();
1394 #endif
1395 #endif
1396
1397   fflush (stdout);
1398 #ifdef VMS
1399   mapout_data (XSTRING (filename)->data);
1400 #else
1401   /* Tell malloc where start of impure now is */
1402   /* Also arrange for warnings when nearly out of space.  */
1403 #ifndef SYSTEM_MALLOC
1404 #ifndef WINDOWSNT
1405   /* On Windows, this was done before dumping, and that once suffices.
1406      Meanwhile, my_edata is not valid on Windows.  */
1407   memory_warnings (my_edata, malloc_warning);
1408 #endif /* not WINDOWSNT */
1409 #endif
1410   unexec (XSTRING (filename)->data,
1411           !NILP (symfile) ? XSTRING (symfile)->data : 0, my_edata, 0, 0);
1412 #endif /* not VMS */
1413
1414   Vpurify_flag = tem;
1415
1416   return Qnil;
1417 }
1418
1419 #endif /* not HAVE_SHM */
1420
1421 #endif /* not CANNOT_DUMP */
1422 \f
1423 #ifndef SEPCHAR
1424 #define SEPCHAR ':'
1425 #endif
1426
1427 Lisp_Object
1428 decode_env_path (evarname, defalt)
1429      char *evarname, *defalt;
1430 {
1431   register char *path, *p;
1432
1433   Lisp_Object lpath;
1434
1435   /* It's okay to use getenv here, because this function is only used
1436      to initialize variables when Emacs starts up, and isn't called
1437      after that.  */
1438   if (evarname != 0)
1439     path = (char *) getenv (evarname);
1440   else
1441     path = 0;
1442   if (!path)
1443     path = defalt;
1444   lpath = Qnil;
1445   while (1)
1446     {
1447       p = index (path, SEPCHAR);
1448       if (!p) p = path + strlen (path);
1449       lpath = Fcons (p - path ? make_string (path, p - path)
1450                      : build_string ("."),
1451                      lpath);
1452       if (*p)
1453         path = p + 1;
1454       else
1455         break;
1456     }
1457   return Fnreverse (lpath);
1458 }
1459
1460 syms_of_emacs ()
1461 {
1462 #ifndef CANNOT_DUMP
1463 #ifdef HAVE_SHM
1464   defsubr (&Sdump_emacs_data);
1465 #else
1466   defsubr (&Sdump_emacs);
1467 #endif
1468 #endif
1469
1470   defsubr (&Skill_emacs);
1471
1472   defsubr (&Sinvocation_name);
1473   defsubr (&Sinvocation_directory);
1474
1475   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
1476     "Args passed by shell to Emacs, as a list of strings.");
1477
1478   DEFVAR_LISP ("system-type", &Vsystem_type,
1479     "Value is symbol indicating type of operating system you are using.");
1480   Vsystem_type = intern (SYSTEM_TYPE);
1481
1482   DEFVAR_LISP ("system-configuration", &Vsystem_configuration,
1483     "Value is string indicating configuration Emacs was built for.");
1484   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1485
1486   DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options,
1487     "String containing the configuration options Emacs was built with.");
1488   Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS);
1489
1490   DEFVAR_BOOL ("noninteractive", &noninteractive1,
1491     "Non-nil means Emacs is running without interactive terminal.");
1492
1493   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
1494     "Hook to be run whenever kill-emacs is called.\n\
1495 Since kill-emacs may be invoked when the terminal is disconnected (or\n\
1496 in other similar situations), functions placed on this hook should not\n\
1497 expect to be able to interact with the user.  To ask for confirmation,\n\
1498 see `kill-emacs-query-functions' instead.");
1499   Vkill_emacs_hook = Qnil;
1500
1501   DEFVAR_INT ("emacs-priority", &emacs_priority,
1502     "Priority for Emacs to run at.\n\
1503 This value is effective only if set before Emacs is dumped,\n\
1504 and only if the Emacs executable is installed with setuid to permit\n\
1505 it to change priority.  (Emacs sets its uid back to the real uid.)\n\
1506 Currently, you need to define SET_EMACS_PRIORITY in `config.h'\n\
1507 before you compile Emacs, to enable the code for this feature.");
1508   emacs_priority = 0;
1509
1510   DEFVAR_LISP ("invocation-name", &Vinvocation_name,
1511     "The program name that was used to run Emacs.\n\
1512 Any directory names are omitted.");
1513
1514   DEFVAR_LISP ("invocation-directory", &Vinvocation_directory,
1515     "The directory in which the Emacs executable was found, to run it.\n\
1516 The value is nil if that directory's name is not known.");
1517
1518   DEFVAR_LISP ("installation-directory", &Vinstallation_directory,
1519     "A directory within which to look for the `lib-src' and `etc' directories.\n\
1520 This is non-nil when we can't find those directories in their standard\n\
1521 installed locations, but we can find them\n\
1522 near where the Emacs executable was found.");
1523   Vinstallation_directory = Qnil;
1524 }