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