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       if (newlim > rlim.rlim_max)
 588         newlim = rlim.rlim_max;
 589       if (rlim.rlim_cur < newlim)
 590         rlim.rlim_cur = newlim;
 591
 592       setrlimit (RLIMIT_STACK, &rlim);
 593     }
 594 #endif
 595
 596   /* Record (approximately) where the stack begins.  */
 597   stack_bottom = &stack_bottom_variable;
 598
 599 #ifdef RUN_TIME_REMAP
 600   if (initialized)
 601     run_time_remap (argv[0]);
 602 #endif
 603
 604 #ifdef USG_SHARED_LIBRARIES
 605   if (bss_end)
 606     brk ((void *)bss_end);
 607 #endif
 608
 609   clearerr (stdin);
 610
 611 #ifndef SYSTEM_MALLOC
 612   if (! initialized)
 613     {
 614       /* Arrange to get warning messages as memory fills up.  */
 615       memory_warnings (0, malloc_warning);
 616
 617       /* Arrange to disable interrupt input while malloc and friends are
 618          running.  */
 619       uninterrupt_malloc ();
 620     }
 621 #endif  /* not SYSTEM_MALLOC */
 622
 623 #ifdef MSDOS
 624   /* We do all file input/output as binary files.  When we need to translate
 625      newlines, we do that manually.  */
 626   _fmode = O_BINARY;
 627
 628 #if __DJGPP__ >= 2
 629   if (!isatty (fileno (stdin)))
 630     setmode (fileno (stdin), O_BINARY);
 631   if (!isatty (fileno (stdout)))
 632     {
 633       fflush (stdout);
 634       setmode (fileno (stdout), O_BINARY);
 635     }
 636 #else  /* not __DJGPP__ >= 2 */
 637   (stdin)->_flag &= ~_IOTEXT;
 638   (stdout)->_flag &= ~_IOTEXT;
 639   (stderr)->_flag &= ~_IOTEXT;
 640 #endif /* not __DJGPP__ >= 2 */
 641 #endif /* MSDOS */
 642
 643 #ifdef SET_EMACS_PRIORITY
 644   if (emacs_priority)
 645     nice (emacs_priority);
 646   setuid (getuid ());
 647 #endif /* SET_EMACS_PRIORITY */
 648
 649 #ifdef EXTRA_INITIALIZE
 650   EXTRA_INITIALIZE;
 651 #endif
 652
 653   inhibit_window_system = 0;
 654
 655   /* Handle the -t switch, which specifies filename to use as terminal */
 656   {
 657     char *term;
 658     if (argmatch (argv, argc, "-t", "--terminal", 4, &term, &skip_args))
 659       {
 660         int result;
 661         close (0);
 662         close (1);
 663         result = open (term, O_RDWR, 2 );
 664         if (result < 0)
 665           {
 666             char *errstring = strerror (errno);
 667             fprintf (stderr, "emacs: %s: %s\n", term, errstring);
 668             exit (1);
 669           }
 670         dup (0);
 671         if (! isatty (0))
 672           {
 673             fprintf (stderr, "emacs: %s: not a tty\n", term);
 674             exit (1);
 675           }
 676         fprintf (stderr, "Using %s\n", term);
 677 #ifdef HAVE_WINDOW_SYSTEM
 678         inhibit_window_system = 1; /* -t => -nw */
 679 #endif
 680       }
 681   }
 682   if (argmatch (argv, argc, "-nw", "--no-windows", 6, NULL, &skip_args))
 683     inhibit_window_system = 1;
 684
 685   /* Handle the -batch switch, which means don't do interactive display.  */
 686   noninteractive = 0;
 687   if (argmatch (argv, argc, "-batch", "--batch", 5, NULL, &skip_args))
 688     noninteractive = 1;
 689
 690   /* Handle the --help option, which gives a usage message..  */
 691   if (argmatch (argv, argc, "-help", "--help", 3, NULL, &skip_args))
 692     {
 693       printf ("\
 694 Usage: %s [-t term] [--terminal term]  [-nw] [--no-windows]  [--batch]\n\
 695       [-q] [--no-init-file]  [-u user] [--user user]  [--debug-init]\n\
 696       [--version] [--no-site-file]\n\
 697       [-f func] [--funcall func]  [-l file] [--load file]  [--insert file]\n\
 698       [+linenum] file-to-visit  [--kill]\n\
 699 Report bugs to bug-gnu-emacs@prep.ai.mit.edu.  First, please see\n\
 700 the Bugs section of the Emacs manual or the file BUGS.", argv[0]);
 701       exit (0);
 702     }
 703
 704 #ifdef HAVE_X_WINDOWS
 705   /* Stupid kludge to catch command-line display spec.  We can't
 706      handle this argument entirely in window system dependent code
 707      because we don't even know which window system dependent code
 708      to run until we've recognized this argument.  */
 709   {
 710     char *displayname = 0;
 711     int i;
 712     int count_before = skip_args;
 713
 714     if (argmatch (argv, argc, "-d", "--display", 3, &displayname, &skip_args))
 715       display_arg = 1;
 716     else if (argmatch (argv, argc, "-display", 0, 3, &displayname, &skip_args))
 717       display_arg = 1;
 718
 719     /* If we have the form --display=NAME,
 720        convert it into  -d name.
 721        This requires inserting a new element into argv.  */
 722     if (displayname != 0 && skip_args - count_before == 1)
 723       {
 724         char **new = (char **) xmalloc (sizeof (char *) * (argc + 2));
 725         int j;
 726
 727         for (j = 0; j < count_before + 1; j++)
 728           new[j] = argv[j];
 729         new[count_before + 1] = "-d";
 730         new[count_before + 2] = displayname;
 731         for (j = count_before + 2; j <argc; j++)
 732           new[j + 1] = argv[j];
 733         argv = new;
 734         argc++;
 735       }
 736     /* Change --display to -d, when its arg is separate.  */
 737     else if (displayname != 0 && skip_args > count_before
 738              && argv[count_before + 1][1] == '-')
 739       argv[count_before + 1] = "-d";
 740
 741     /* Don't actually discard this arg.  */
 742     skip_args = count_before;
 743   }
 744 #endif
 745
 746   if (! noninteractive)
 747     {
 748 #ifdef BSD_PGRPS
 749       if (initialized)
 750         {
 751           inherited_pgroup = EMACS_GETPGRP (0);
 752           setpgrp (0, getpid ());
 753         }
 754 #else
 755 #if defined (USG5) && defined (INTERRUPT_INPUT)
 756       setpgrp ();
 757 #endif
 758 #endif
 759     }
 760
 761 #ifdef POSIX_SIGNALS
 762   init_signals ();
 763 #endif
 764
 765   /* Don't catch SIGHUP if dumping.  */
 766   if (1
 767 #ifndef CANNOT_DUMP
 768       && initialized
 769 #endif
 770       )
 771     {
 772       sigblock (sigmask (SIGHUP));
 773       /* In --batch mode, don't catch SIGHUP if already ignored.
 774          That makes nohup work.  */
 775       if (! noninteractive
 776           || signal (SIGHUP, SIG_IGN) != SIG_IGN)
 777         signal (SIGHUP, fatal_error_signal);
 778       sigunblock (sigmask (SIGHUP));
 779     }
 780
 781   if (
 782 #ifndef CANNOT_DUMP
 783       ! noninteractive || initialized
 784 #else
 785       1
 786 #endif
 787       )
 788     {
 789       /* Don't catch these signals in batch mode if dumping.
 790          On some machines, this sets static data that would make
 791          signal fail to work right when the dumped Emacs is run.  */
 792       signal (SIGQUIT, fatal_error_signal);
 793       signal (SIGILL, fatal_error_signal);
 794       signal (SIGTRAP, fatal_error_signal);
 795 #ifdef SIGABRT
 796       signal (SIGABRT, fatal_error_signal);
 797 #endif
 798 #ifdef SIGHWE
 799       signal (SIGHWE, fatal_error_signal);
 800 #endif
 801 #ifdef SIGPRE
 802       signal (SIGPRE, fatal_error_signal);
 803 #endif
 804 #ifdef SIGORE
 805       signal (SIGORE, fatal_error_signal);
 806 #endif
 807 #ifdef SIGUME
 808       signal (SIGUME, fatal_error_signal);
 809 #endif
 810 #ifdef SIGDLK
 811       signal (SIGDLK, fatal_error_signal);
 812 #endif
 813 #ifdef SIGCPULIM
 814       signal (SIGCPULIM, fatal_error_signal);
 815 #endif
 816 #ifdef SIGIOT
 817       /* This is missing on some systems - OS/2, for example.  */
 818       signal (SIGIOT, fatal_error_signal);
 819 #endif
 820 #ifdef SIGEMT
 821       signal (SIGEMT, fatal_error_signal);
 822 #endif
 823       signal (SIGFPE, fatal_error_signal);
 824 #ifdef SIGBUS
 825       signal (SIGBUS, fatal_error_signal);
 826 #endif
 827       signal (SIGSEGV, fatal_error_signal);
 828 #ifdef SIGSYS
 829       signal (SIGSYS, fatal_error_signal);
 830 #endif
 831       signal (SIGTERM, fatal_error_signal);
 832 #ifdef SIGXCPU
 833       signal (SIGXCPU, fatal_error_signal);
 834 #endif
 835 #ifdef SIGXFSZ
 836       signal (SIGXFSZ, fatal_error_signal);
 837 #endif /* SIGXFSZ */
 838
 839 #ifdef SIGDANGER
 840       /* This just means available memory is getting low.  */
 841       signal (SIGDANGER, memory_warning_signal);
 842 #endif
 843
 844 #ifdef AIX
 845 /* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU.  */
 846       signal (SIGXCPU, fatal_error_signal);
 847 #ifndef _I386
 848       signal (SIGIOINT, fatal_error_signal);
 849 #endif
 850       signal (SIGGRANT, fatal_error_signal);
 851       signal (SIGRETRACT, fatal_error_signal);
 852       signal (SIGSOUND, fatal_error_signal);
 853       signal (SIGMSG, fatal_error_signal);
 854 #endif /* AIX */
 855     }
 856
 857   noninteractive1 = noninteractive;
 858
 859 /* Perform basic initializations (not merely interning symbols) */
 860
 861   if (!initialized)
 862     {
 863       init_alloc_once ();
 864       init_obarray ();
 865       init_eval_once ();
 866       init_charset_once ();
 867       init_coding_once ();
 868       init_syntax_once ();      /* Create standard syntax table.  */
 869       init_category_once ();    /* Create standard category table.  */
 870                       /* Must be done before init_buffer */
 871       init_casetab_once ();
 872       init_buffer_once ();      /* Create buffer table and some buffers */
 873       init_minibuf_once ();     /* Create list of minibuffers */
 874                               /* Must precede init_window_once */
 875       init_window_once ();      /* Init the window system */
 876     }
 877
 878   init_alloc ();
 879   init_eval ();
 880   init_data ();
 881   running_asynch_code = 0;
 882
 883 #ifdef MSDOS
 884   /* Call early 'cause init_environment needs it.  */
 885   init_dosfns ();
 886   /* Set defaults for several environment variables.  */
 887   if (initialized)
 888     init_environment (argc, argv, skip_args);
 889   else
 890     tzset ();
 891 #endif /* MSDOS */
 892
 893 #ifdef WINDOWSNT
 894   /* Initialize environment from registry settings.  */
 895   init_environment ();
 896   init_ntproc ();       /* must precede init_editfns */
 897 #endif
 898
 899   /* egetenv is a pretty low-level facility, which may get called in
 900      many circumstances; it seems flimsy to put off initializing it
 901      until calling init_callproc.  */
 902   set_process_environment ();
 903   /* AIX crashes are reported in system versions 3.2.3 and 3.2.4
 904      if this is not done.  Do it after set_process_environment so that we
 905      don't pollute Vprocess_environment.  */
 906 #ifdef AIX
 907   putenv ("LANG=C");
 908 #endif
 909
 910   init_buffer ();       /* Init default directory of main buffer */
 911
 912   init_callproc_1 ();   /* Must precede init_cmdargs and init_sys_modes.  */
 913   init_cmdargs (argc, argv, skip_args); /* Must precede init_lread.  */
 914
 915   if (initialized)
 916     {
 917       /* Erase any pre-dump messages in the message log, to avoid confusion */
 918       Lisp_Object old_log_max;
 919       old_log_max = Vmessage_log_max;
 920       XSETFASTINT (Vmessage_log_max, 0);
 921       message_dolog ("", 0, 1);
 922       Vmessage_log_max = old_log_max;
 923     }
 924
 925   init_callproc ();     /* Must follow init_cmdargs but not init_sys_modes.  */
 926   init_lread ();
 927
 928   if (!noninteractive)
 929     {
 930 #ifdef VMS
 931       init_vms_input ();/* init_display calls get_frame_size, that needs this */
 932 #endif /* VMS */
 933       init_display ();  /* Determine terminal type.  init_sys_modes uses results */
 934     }
 935   init_keyboard ();     /* This too must precede init_sys_modes */
 936 #ifdef VMS
 937   init_vmsproc ();      /* And this too. */
 938 #endif /* VMS */
 939   init_sys_modes ();    /* Init system terminal modes (RAW or CBREAK, etc.) */
 940   init_xdisp ();
 941   init_macros ();
 942   init_editfns ();
 943 #ifdef LISP_FLOAT_TYPE
 944   init_floatfns ();
 945 #endif
 946 #ifdef VMS
 947   init_vmsfns ();
 948 #endif /* VMS */
 949   init_process ();
 950 #ifdef CLASH_DETECTION
 951   init_filelock ();
 952 #endif /* CLASH_DETECTION */
 953
 954 /* Intern the names of all standard functions and variables; define standard keys */
 955
 956   if (!initialized)
 957     {
 958       /* The basic levels of Lisp must come first */
 959       /* And data must come first of all
 960          for the sake of symbols like error-message */
 961       syms_of_data ();
 962       syms_of_alloc ();
 963       syms_of_lread ();
 964       syms_of_print ();
 965       syms_of_eval ();
 966       syms_of_fns ();
 967       syms_of_floatfns ();
 968
 969       syms_of_abbrev ();
 970       syms_of_buffer ();
 971       syms_of_bytecode ();
 972       syms_of_callint ();
 973       syms_of_casefiddle ();
 974       syms_of_casetab ();
 975       syms_of_callproc ();
 976       syms_of_category ();
 977       syms_of_ccl ();
 978       syms_of_charset ();
 979       syms_of_cmds ();
 980 #ifndef NO_DIR_LIBRARY
 981       syms_of_dired ();
 982 #endif /* not NO_DIR_LIBRARY */
 983       syms_of_display ();
 984       syms_of_doc ();
 985       syms_of_editfns ();
 986       syms_of_emacs ();
 987       syms_of_fileio ();
 988       syms_of_coding ();        /* This should be after syms_of_fileio.  */
 989 #ifdef CLASH_DETECTION
 990       syms_of_filelock ();
 991 #endif /* CLASH_DETECTION */
 992       syms_of_indent ();
 993       syms_of_insdel ();
 994       syms_of_keyboard ();
 995       syms_of_keymap ();
 996       syms_of_macros ();
 997       syms_of_marker ();
 998       syms_of_minibuf ();
 999       syms_of_mocklisp ();
1000       syms_of_process ();
1001       syms_of_search ();
1002       syms_of_frame ();
1003       syms_of_syntax ();
1004       syms_of_term ();
1005       syms_of_undo ();
1006
1007       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1008       syms_of_textprop ();
1009 #ifdef VMS
1010       syms_of_vmsproc ();
1011 #endif /* VMS */
1012 #ifdef WINDOWSNT
1013       syms_of_ntproc ();
1014 #endif /* WINDOWSNT */
1015       syms_of_window ();
1016       syms_of_xdisp ();
1017 #ifdef HAVE_X_WINDOWS
1018       syms_of_xterm ();
1019       syms_of_xfns ();
1020       syms_of_xfaces ();
1021       syms_of_fontset ();
1022 #ifdef HAVE_X11
1023       syms_of_xselect ();
1024 #endif
1025 #endif /* HAVE_X_WINDOWS */
1026
1027 #if defined (MSDOS) && !defined (HAVE_X_WINDOWS)
1028       syms_of_xfaces ();
1029 #endif
1030
1031 #ifndef HAVE_NTGUI
1032       syms_of_xmenu ();
1033 #endif
1034
1035 #ifdef HAVE_NTGUI
1036       syms_of_w32term ();
1037       syms_of_w32fns ();
1038       syms_of_w32faces ();
1039       syms_of_w32select ();
1040       syms_of_w32menu ();
1041 #endif /* HAVE_NTGUI */
1042
1043 #ifdef SYMS_SYSTEM
1044       SYMS_SYSTEM;
1045 #endif
1046
1047 #ifdef SYMS_MACHINE
1048       SYMS_MACHINE;
1049 #endif
1050
1051       keys_of_casefiddle ();
1052       keys_of_cmds ();
1053       keys_of_buffer ();
1054       keys_of_keyboard ();
1055       keys_of_keymap ();
1056       keys_of_macros ();
1057       keys_of_minibuf ();
1058       keys_of_window ();
1059       keys_of_frame ();
1060     }
1061
1062   if (!initialized)
1063     {
1064       char *file;
1065       /* Handle -l loadup-and-dump, args passed by Makefile. */
1066       if (argmatch (argv, argc, "-l", "--load", 3, &file, &skip_args))
1067         Vtop_level = Fcons (intern ("load"),
1068                             Fcons (build_string (file), Qnil));
1069 #ifdef CANNOT_DUMP
1070       /* Unless next switch is -nl, load "loadup.el" first thing.  */
1071       if (!argmatch (argv, argc, "-nl", "--no-loadup", 6, NULL, &skip_args))
1072         Vtop_level = Fcons (intern ("load"),
1073                             Fcons (build_string ("loadup.el"), Qnil));
1074 #endif /* CANNOT_DUMP */
1075     }
1076
1077   if (initialized)
1078     {
1079 #ifdef HAVE_TZSET
1080       {
1081         /* If the execution TZ happens to be the same as the dump TZ,
1082            change it to some other value and then change it back,
1083            to force the underlying implementation to reload the TZ info.
1084            This is needed on implementations that load TZ info from files,
1085            since the TZ file contents may differ between dump and execution.  */
1086         char *tz = getenv ("TZ");
1087         if (tz && !strcmp (tz, dump_tz))
1088           {
1089             ++*tz;
1090             tzset ();
1091             --*tz;
1092           }
1093       }
1094 #endif
1095     }
1096
1097   initialized = 1;
1098
1099 #ifdef LOCALTIME_CACHE
1100   /* Some versions of localtime have a bug.  They cache the value of the time
1101      zone rather than looking it up every time.  Since localtime() is
1102      called to bolt the undumping time into the undumped emacs, this
1103      results in localtime ignoring the TZ environment variable.
1104      This flushes the new TZ value into localtime. */
1105   tzset ();
1106 #endif /* defined (LOCALTIME_CACHE) */
1107
1108   /* Enter editor command loop.  This never returns.  */
1109   Frecursive_edit ();
1110   /* NOTREACHED */
1111 }
1112 \f
1113 /* Sort the args so we can find the most important ones
1114    at the beginning of argv.  */
1115
1116 /* First, here's a table of all the standard options.  */
1117
1118 struct standard_args
1119 {
1120   char *name;
1121   char *longname;
1122   int priority;
1123   int nargs;
1124 };
1125
1126 struct standard_args standard_args[] =
1127 {
1128   { "-version", "--version", 110, 0 },
1129   { "-help", "--help", 110, 0 },
1130   { "-nl", "--no-shared-memory", 100, 0 },
1131 #ifdef VMS
1132   { "-map", "--map-data", 100, 0 },
1133 #endif
1134   { "-t", "--terminal", 90, 1 },
1135   { "-d", "--display", 80, 1 },
1136   { "-display", 0, 80, 1 },
1137   { "-nw", "--no-windows", 70, 0 },
1138   { "-batch", "--batch", 60, 0 },
1139   { "-q", "--no-init-file", 50, 0 },
1140   { "-no-init-file", 0, 50, 0 },
1141   { "-no-site-file", "--no-site-file", 40, 0 },
1142   { "-u", "--user", 30, 1 },
1143   { "-user", 0, 30, 1 },
1144   { "-debug-init", "--debug-init", 20, 0 },
1145   { "-i", "--icon-type", 15, 0 },
1146   { "-itype", 0, 15, 0 },
1147   { "-iconic", "--iconic", 15, 0 },
1148   { "-bg", "--background-color", 10, 1 },
1149   { "-background", 0, 10, 1 },
1150   { "-fg", "--foreground-color", 10, 1 },
1151   { "-foreground", 0, 10, 1 },
1152   { "-bd", "--border-color", 10, 1 },
1153   { "-bw", "--border-width", 10, 1 },
1154   { "-ib", "--internal-border", 10, 1 },
1155   { "-ms", "--mouse-color", 10, 1 },
1156   { "-cr", "--cursor-color", 10, 1 },
1157   { "-fn", "--font", 10, 1 },
1158   { "-font", 0, 10, 1 },
1159   { "-g", "--geometry", 10, 1 },
1160   { "-geometry", 0, 10, 1 },
1161   { "-T", "--title", 10, 1 },
1162   { "-title", 0, 10, 1 },
1163   { "-name", "--name", 10, 1 },
1164   { "-xrm", "--xrm", 10, 1 },
1165   { "-r", "--reverse-video", 5, 0 },
1166   { "-rv", 0, 5, 0 },
1167   { "-reverse", 0, 5, 0 },
1168   { "-hb", "--horizontal-scroll-bars", 5, 0 },
1169   { "-vb", "--vertical-scroll-bars", 5, 0 },
1170   /* These have the same priority as ordinary file name args,
1171      so they are not reordered with respect to those.  */
1172   { "-L", "--directory", 0, 1 },
1173   { "-directory", 0, 0, 1 },
1174   { "-l", "--load", 0, 1 },
1175   { "-load", 0, 0, 1 },
1176   { "-f", "--funcall", 0, 1 },
1177   { "-funcall", 0, 0, 1 },
1178   { "-eval", "--eval", 0, 1 },
1179   { "-find-file", "--find-file", 0, 1 },
1180   { "-visit", "--visit", 0, 1 },
1181   { "-insert", "--insert", 0, 1 },
1182   /* This should be processed after ordinary file name args and the like.  */
1183   { "-kill", "--kill", -10, 0 },
1184 };
1185
1186 /* Reorder the elements of ARGV (assumed to have ARGC elements)
1187    so that the highest priority ones come first.
1188    Do not change the order of elements of equal priority.
1189    If an option takes an argument, keep it and its argument together.  */
1190
1191 static void
1192 sort_args (argc, argv)
1193      int argc;
1194      char **argv;
1195 {
1196   char **new = (char **) xmalloc (sizeof (char *) * argc);
1197   /* For each element of argv,
1198      the corresponding element of options is:
1199      0 for an option that takes no arguments,
1200      1 for an option that takes one argument, etc.
1201      -1 for an ordinary non-option argument.  */
1202   int *options = (int *) xmalloc (sizeof (int) * argc);
1203   int *priority = (int *) xmalloc (sizeof (int) * argc);
1204   int to = 1;
1205   int from;
1206   int i;
1207   int end_of_options = argc;
1208
1209   /* Categorize all the options,
1210      and figure out which argv elts are option arguments.  */
1211   for (from = 1; from < argc; from++)
1212     {
1213       options[from] = -1;
1214       priority[from] = 0;
1215       if (argv[from][0] == '-')
1216         {
1217           int match, thislen;
1218           char *equals;
1219
1220           /* If we have found "--", don't consider
1221              any more arguments as options.  */
1222           if (argv[from][1] == '-')
1223             {
1224               /* Leave the "--", and everything following it, at the end.  */
1225               for (; from < argc; from++)
1226                 {
1227                   priority[from] = -100;
1228                   options[from] = -1;
1229                 }
1230               break;
1231             }
1232
1233           /* Look for a match with a known old-fashioned option.  */
1234           for (i = 0; i < sizeof (standard_args) / sizeof (standard_args[0]); i++)
1235             if (!strcmp (argv[from], standard_args[i].name))
1236               {
1237                 options[from] = standard_args[i].nargs;
1238                 priority[from] = standard_args[i].priority;
1239                 if (from + standard_args[i].nargs >= argc)
1240                   fatal ("Option `%s' requires an argument\n", argv[from]);
1241                 from += standard_args[i].nargs;
1242                 goto done;
1243               }
1244
1245           /* Look for a match with a known long option.
1246              MATCH is -1 if no match so far, -2 if two or more matches so far,
1247              >= 0 (the table index of the match) if just one match so far.  */
1248           if (argv[from][1] == '-')
1249             {
1250               match = -1;
1251               thislen = strlen (argv[from]);
1252               equals = index (argv[from], '=');
1253               if (equals != 0)
1254                 thislen = equals - argv[from];
1255
1256               for (i = 0;
1257                    i < sizeof (standard_args) / sizeof (standard_args[0]); i++)
1258                 if (standard_args[i].longname
1259                     && !strncmp (argv[from], standard_args[i].longname,
1260                                  thislen))
1261                   {
1262                     if (match == -1)
1263                       match = i;
1264                     else
1265                       match = -2;
1266                   }
1267
1268               /* If we found exactly one match, use that.  */
1269               if (match >= 0)
1270                 {
1271                   options[from] = standard_args[match].nargs;
1272                   priority[from] = standard_args[match].priority;
1273                   /* If --OPTION=VALUE syntax is used,
1274                      this option uses just one argv element.  */
1275                   if (equals != 0)
1276                     options[from] = 0;
1277                   if (from + options[from] >= argc)
1278                     fatal ("Option `%s' requires an argument\n", argv[from]);
1279                   from += options[from];
1280                 }
1281             }
1282         done: ;
1283         }
1284     }
1285
1286   /* Copy the arguments, in order of decreasing priority, to NEW.  */
1287   new[0] = argv[0];
1288   while (to < argc)
1289     {
1290       int best = -1;
1291       int best_priority = -9999;
1292
1293       /* Find the highest priority remaining option.
1294          If several have equal priority, take the first of them.  */
1295       for (from = 1; from < argc; from++)
1296         {
1297           if (argv[from] != 0 && priority[from] > best_priority)
1298             {
1299               best_priority = priority[from];
1300               best = from;
1301             }
1302           /* Skip option arguments--they are tied to the options.  */
1303           if (options[from] > 0)
1304             from += options[from];
1305         }
1306
1307       if (best < 0)
1308         abort ();
1309
1310       /* Copy the highest priority remaining option, with its args, to NEW.  */
1311       new[to++] = argv[best];
1312       for (i = 0; i < options[best]; i++)
1313         new[to++] = argv[best + i + 1];
1314
1315       /* Clear out this option in ARGV.  */
1316       argv[best] = 0;
1317       for (i = 0; i < options[best]; i++)
1318         argv[best + i + 1] = 0;
1319     }
1320
1321   bcopy (new, argv, sizeof (char *) * argc);
1322 }
1323 \f
1324 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
1325   "Exit the Emacs job and kill it.\n\
1326 If ARG is an integer, return ARG as the exit program code.\n\
1327 If ARG is a  string, stuff it as keyboard input.\n\n\
1328 The value of `kill-emacs-hook', if not void,\n\
1329 is a list of functions (of no args),\n\
1330 all of which are called before Emacs is actually killed.")
1331   (arg)
1332      Lisp_Object arg;
1333 {
1334   Lisp_Object hook, hook1;
1335   int i;
1336   struct gcpro gcpro1;
1337
1338   GCPRO1 (arg);
1339
1340   if (feof (stdin))
1341     arg = Qt;
1342
1343   if (!NILP (Vrun_hooks) && !noninteractive)
1344     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
1345
1346   UNGCPRO;
1347
1348 /* Is it really necessary to do this deassign
1349    when we are going to exit anyway?  */
1350 /* #ifdef VMS
1351   stop_vms_input ();
1352  #endif  */
1353
1354   shut_down_emacs (0, 0, STRINGP (arg) ? arg : Qnil);
1355
1356   /* If we have an auto-save list file,
1357      kill it because we are exiting Emacs deliberately (not crashing).
1358      Do it after shut_down_emacs, which does an auto-save.  */
1359   if (STRINGP (Vauto_save_list_file_name))
1360     unlink (XSTRING (Vauto_save_list_file_name)->data);
1361
1362   exit (INTEGERP (arg) ? XINT (arg)
1363 #ifdef VMS
1364         : 1
1365 #else
1366         : 0
1367 #endif
1368         );
1369   /* NOTREACHED */
1370 }
1371
1372
1373 /* Perform an orderly shutdown of Emacs.  Autosave any modified
1374    buffers, kill any child processes, clean up the terminal modes (if
1375    we're in the foreground), and other stuff like that.  Don't perform
1376    any redisplay; this may be called when Emacs is shutting down in
1377    the background, or after its X connection has died.
1378
1379    If SIG is a signal number, print a message for it.
1380
1381    This is called by fatal signal handlers, X protocol error handlers,
1382    and Fkill_emacs.  */
1383
1384 void
1385 shut_down_emacs (sig, no_x, stuff)
1386      int sig, no_x;
1387      Lisp_Object stuff;
1388 {
1389   /* Prevent running of hooks from now on.  */
1390   Vrun_hooks = Qnil;
1391
1392   /* If we are controlling the terminal, reset terminal modes */
1393 #ifdef EMACS_HAVE_TTY_PGRP
1394   {
1395     int pgrp = EMACS_GETPGRP (0);
1396
1397     int tpgrp;
1398     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
1399         && tpgrp == pgrp)
1400       {
1401         fflush (stdout);
1402         reset_sys_modes ();
1403         if (sig && sig != SIGTERM)
1404           fprintf (stderr, "Fatal error (%d).", sig);
1405       }
1406   }
1407 #else
1408   fflush (stdout);
1409   reset_sys_modes ();
1410 #endif
1411
1412   stuff_buffered_input (stuff);
1413
1414   kill_buffer_processes (Qnil);
1415   Fdo_auto_save (Qt, Qnil);
1416
1417 #ifdef CLASH_DETECTION
1418   unlock_all_files ();
1419 #endif
1420
1421 #ifdef VMS
1422   kill_vms_processes ();
1423 #endif
1424
1425 #if 0 /* This triggers a bug in XCloseDisplay and is not needed.  */
1426 #ifdef HAVE_X_WINDOWS
1427   /* It's not safe to call intern here.  Maybe we are crashing.  */
1428   if (!noninteractive && SYMBOLP (Vwindow_system)
1429       && XSYMBOL (Vwindow_system)->name->size == 1
1430       && XSYMBOL (Vwindow_system)->name->data[0] == 'x'
1431       && ! no_x)
1432     Fx_close_current_connection ();
1433 #endif /* HAVE_X_WINDOWS */
1434 #endif
1435
1436 #ifdef SIGIO
1437   /* There is a tendency for a SIGIO signal to arrive within exit,
1438      and cause a SIGHUP because the input descriptor is already closed.  */
1439   unrequest_sigio ();
1440   signal (SIGIO, SIG_IGN);
1441 #endif
1442
1443 #ifdef WINDOWSNT
1444   term_ntproc ();
1445 #endif
1446 }
1447
1448
1449 \f
1450 #ifndef CANNOT_DUMP
1451
1452 #ifdef HAVE_SHM
1453
1454 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
1455   "Dump current state of Emacs into data file FILENAME.\n\
1456 This function exists on systems that use HAVE_SHM.")
1457   (filename)
1458      Lisp_Object filename;
1459 {
1460   extern char my_edata[];
1461   Lisp_Object tem;
1462
1463   CHECK_STRING (filename, 0);
1464   filename = Fexpand_file_name (filename, Qnil);
1465
1466   tem = Vpurify_flag;
1467   Vpurify_flag = Qnil;
1468
1469   fflush (stdout);
1470   /* Tell malloc where start of impure now is */
1471   /* Also arrange for warnings when nearly out of space.  */
1472 #ifndef SYSTEM_MALLOC
1473   memory_warnings (my_edata, malloc_warning);
1474 #endif
1475   map_out_data (XSTRING (filename)->data);
1476
1477   Vpurify_flag = tem;
1478
1479   return Qnil;
1480 }
1481
1482 #else /* not HAVE_SHM */
1483
1484 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
1485   "Dump current state of Emacs into executable file FILENAME.\n\
1486 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
1487 This is used in the file `loadup.el' when building Emacs.\n\
1488 \n\
1489 Bind `command-line-processed' to nil before dumping,\n\
1490 if you want the dumped Emacs to process its command line\n\
1491 and announce itself normally when it is run.")
1492   (filename, symfile)
1493      Lisp_Object filename, symfile;
1494 {
1495   extern char my_edata[];
1496   Lisp_Object tem;
1497
1498   CHECK_STRING (filename, 0);
1499   filename = Fexpand_file_name (filename, Qnil);
1500   if (!NILP (symfile))
1501     {
1502       CHECK_STRING (symfile, 0);
1503       if (XSTRING (symfile)->size)
1504         symfile = Fexpand_file_name (symfile, Qnil);
1505     }
1506
1507   tem = Vpurify_flag;
1508   Vpurify_flag = Qnil;
1509
1510 #ifdef HAVE_TZSET
1511   set_time_zone_rule (dump_tz);
1512 #ifndef LOCALTIME_CACHE
1513   /* Force a tz reload, since set_time_zone_rule doesn't.  */
1514   tzset ();
1515 #endif
1516 #endif
1517
1518   fflush (stdout);
1519 #ifdef VMS
1520   mapout_data (XSTRING (filename)->data);
1521 #else
1522   /* Tell malloc where start of impure now is */
1523   /* Also arrange for warnings when nearly out of space.  */
1524 #ifndef SYSTEM_MALLOC
1525 #ifndef WINDOWSNT
1526   /* On Windows, this was done before dumping, and that once suffices.
1527      Meanwhile, my_edata is not valid on Windows.  */
1528   memory_warnings (my_edata, malloc_warning);
1529 #endif /* not WINDOWSNT */
1530 #endif
1531 #ifdef DOUG_LEA_MALLOC
1532   malloc_state_ptr = malloc_get_state ();
1533 #endif
1534   unexec (XSTRING (filename)->data,
1535           !NILP (symfile) ? XSTRING (symfile)->data : 0, my_edata, 0, 0);
1536 #ifdef DOUG_LEA_MALLOC
1537   free (malloc_state_ptr);
1538 #endif
1539 #endif /* not VMS */
1540
1541   Vpurify_flag = tem;
1542
1543   return Qnil;
1544 }
1545
1546 #endif /* not HAVE_SHM */
1547
1548 #endif /* not CANNOT_DUMP */
1549 \f
1550 #ifndef SEPCHAR
1551 #define SEPCHAR ':'
1552 #endif
1553
1554 Lisp_Object
1555 decode_env_path (evarname, defalt)
1556      char *evarname, *defalt;
1557 {
1558   register char *path, *p;
1559   Lisp_Object lpath, element, tem;
1560
1561   /* It's okay to use getenv here, because this function is only used
1562      to initialize variables when Emacs starts up, and isn't called
1563      after that.  */
1564   if (evarname != 0)
1565     path = (char *) getenv (evarname);
1566   else
1567     path = 0;
1568   if (!path)
1569     path = defalt;
1570   lpath = Qnil;
1571   while (1)
1572     {
1573       p = index (path, SEPCHAR);
1574       if (!p) p = path + strlen (path);
1575       element = (p - path ? make_string (path, p - path)
1576                  : build_string ("."));
1577
1578       /* Add /: to the front of the name
1579          if it would otherwise be treated as magic.  */
1580       tem = Ffind_file_name_handler (element, Qt);
1581       if (! NILP (tem))
1582         element = concat2 (build_string ("/:"), element);
1583
1584       lpath = Fcons (element, lpath);
1585       if (*p)
1586         path = p + 1;
1587       else
1588         break;
1589     }
1590   return Fnreverse (lpath);
1591 }
1592
1593 syms_of_emacs ()
1594 {
1595   Qfile_name_handler_alist = intern ("file-name-handler-alist");
1596   staticpro (&Qfile_name_handler_alist);
1597
1598 #ifndef CANNOT_DUMP
1599 #ifdef HAVE_SHM
1600   defsubr (&Sdump_emacs_data);
1601 #else
1602   defsubr (&Sdump_emacs);
1603 #endif
1604 #endif
1605
1606   defsubr (&Skill_emacs);
1607
1608   defsubr (&Sinvocation_name);
1609   defsubr (&Sinvocation_directory);
1610
1611   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
1612     "Args passed by shell to Emacs, as a list of strings.");
1613
1614   DEFVAR_LISP ("system-type", &Vsystem_type,
1615     "Value is symbol indicating type of operating system you are using.");
1616   Vsystem_type = intern (SYSTEM_TYPE);
1617
1618   DEFVAR_LISP ("system-configuration", &Vsystem_configuration,
1619     "Value is string indicating configuration Emacs was built for.");
1620   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
1621
1622   DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options,
1623     "String containing the configuration options Emacs was built with.");
1624   Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS);
1625
1626   DEFVAR_BOOL ("noninteractive", &noninteractive1,
1627     "Non-nil means Emacs is running without interactive terminal.");
1628
1629   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
1630     "Hook to be run whenever kill-emacs is called.\n\
1631 Since kill-emacs may be invoked when the terminal is disconnected (or\n\
1632 in other similar situations), functions placed on this hook should not\n\
1633 expect to be able to interact with the user.  To ask for confirmation,\n\
1634 see `kill-emacs-query-functions' instead.");
1635   Vkill_emacs_hook = Qnil;
1636
1637   DEFVAR_INT ("emacs-priority", &emacs_priority,
1638     "Priority for Emacs to run at.\n\
1639 This value is effective only if set before Emacs is dumped,\n\
1640 and only if the Emacs executable is installed with setuid to permit\n\
1641 it to change priority.  (Emacs sets its uid back to the real uid.)\n\
1642 Currently, you need to define SET_EMACS_PRIORITY in `config.h'\n\
1643 before you compile Emacs, to enable the code for this feature.");
1644   emacs_priority = 0;
1645
1646   DEFVAR_LISP ("invocation-name", &Vinvocation_name,
1647     "The program name that was used to run Emacs.\n\
1648 Any directory names are omitted.");
1649
1650   DEFVAR_LISP ("invocation-directory", &Vinvocation_directory,
1651     "The directory in which the Emacs executable was found, to run it.\n\
1652 The value is nil if that directory's name is not known.");
1653
1654   DEFVAR_LISP ("installation-directory", &Vinstallation_directory,
1655     "A directory within which to look for the `lib-src' and `etc' directories.\n\
1656 This is non-nil when we can't find those directories in their standard\n\
1657 installed locations, but we can find them\n\
1658 near where the Emacs executable was found.");
1659   Vinstallation_directory = Qnil;
1660 }