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