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