src/emacs.c

   1 /* Fully extensible Emacs, running on Unix, intended for GNU.
   2    Copyright (C) 1985, 1986, 1987, 1993, 1994 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 #ifdef APOLLO
  39 #ifndef APOLLO_SR10
  40 #include <default_acl.h>
  41 #endif
  42 #endif
  43
  44 #include "lisp.h"
  45 #include "commands.h"
  46 #include "intervals.h"
  47
  48 #include "systty.h"
  49 #include "syssignal.h"
  50 #include "process.h"
  51
  52 #ifndef O_RDWR
  53 #define O_RDWR 2
  54 #endif
  55
  56 extern void malloc_warning ();
  57 extern char *index ();
  58 extern char *strerror ();
  59
  60 /* Command line args from shell, as list of strings */
  61 Lisp_Object Vcommand_line_args;
  62
  63 /* The name under which Emacs was invoked, with any leading directory
  64    names discarded.  */
  65 Lisp_Object Vinvocation_name;
  66
  67 /* The directory name from which Emacs was invoked.  */
  68 Lisp_Object Vinvocation_directory;
  69
  70 /* The directory name in which to find subdirs such as lisp and etc.
  71    nil means get them only from PATH_LOADSEARCH.  */
  72 Lisp_Object Vinstallation_directory;
  73
  74 /* Hook run by `kill-emacs' before it does really anything.  */
  75 Lisp_Object Vkill_emacs_hook;
  76
  77 /* Set nonzero after Emacs has started up the first time.
  78   Prevents reinitialization of the Lisp world and keymaps
  79   on subsequent starts.  */
  80 int initialized;
  81
  82 /* Variable whose value is symbol giving operating system type.  */
  83 Lisp_Object Vsystem_type;
  84
  85 /* Variable whose value is string giving configuration built for.  */
  86 Lisp_Object Vsystem_configuration;
  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 #ifdef BSD
  98 /* See sysdep.c.  */
  99 extern int inherited_pgroup;
 100 #endif
 101
 102 #ifdef HAVE_X_WINDOWS
 103 /* If non-zero, -d was specified, meaning we're using some window system. */
 104 int display_arg;
 105 #endif
 106
 107 /* An address near the bottom of the stack.
 108    Tells GC how to save a copy of the stack.  */
 109 char *stack_bottom;
 110
 111 #ifdef HAVE_X_WINDOWS
 112 extern Lisp_Object Vwindow_system;
 113 #endif /* HAVE_X_WINDOWS */
 114
 115 #ifdef USG_SHARED_LIBRARIES
 116 /* If nonzero, this is the place to put the end of the writable segment
 117    at startup.  */
 118
 119 unsigned int bss_end = 0;
 120 #endif
 121
 122 /* Nonzero means running Emacs without interactive terminal.  */
 123
 124 int noninteractive;
 125
 126 /* Value of Lisp variable `noninteractive'.
 127    Normally same as C variable `noninteractive'
 128    but nothing terrible happens if user sets this one.  */
 129
 130 int noninteractive1;
 131 \f
 132 /* Signal code for the fatal signal that was received */
 133 int fatal_error_code;
 134
 135 /* Nonzero if handling a fatal error already */
 136 int fatal_error_in_progress;
 137
 138 /* Handle bus errors, illegal instruction, etc. */
 139 SIGTYPE
 140 fatal_error_signal (sig)
 141      int sig;
 142 {
 143   fatal_error_code = sig;
 144   signal (sig, SIG_DFL);
 145
 146   /* If fatal error occurs in code below, avoid infinite recursion.  */
 147   if (! fatal_error_in_progress)
 148     {
 149       fatal_error_in_progress = 1;
 150
 151       shut_down_emacs (sig, 0, Qnil);
 152     }
 153
 154 #ifdef VMS
 155   LIB$STOP (SS$_ABORT);
 156 #else
 157   /* Signal the same code; this time it will really be fatal.
 158      Remember that since we're in a signal handler, the signal we're
 159      going to send is probably blocked, so we have to unblock it if we
 160      want to really receive it.  */
 161 #ifndef MSDOS
 162   sigunblock (sigmask (fatal_error_code));
 163 #endif
 164   kill (getpid (), fatal_error_code);
 165 #endif /* not VMS */
 166 }
 167
 168 #ifdef SIGDANGER
 169
 170 /* Handler for SIGDANGER.  */
 171 SIGTYPE
 172 memory_warning_signal (sig)
 173      int sig;
 174 {
 175   signal (sig, memory_warning_signal);
 176
 177   malloc_warning ("Operating system warns that virtual memory is running low.\n");
 178 }
 179 #endif
 180 \f
 181 /* Code for dealing with Lisp access to the Unix command line */
 182
 183 static
 184 init_cmdargs (argc, argv, skip_args)
 185      int argc;
 186      char **argv;
 187      int skip_args;
 188 {
 189   register int i;
 190   Lisp_Object name, dir;
 191
 192   Vinvocation_name = Ffile_name_nondirectory (build_string (argv[0]));
 193   Vinvocation_directory = Ffile_name_directory (build_string (argv[0]));
 194   /* If we got no directory in argv[0], search PATH to find where
 195      Emacs actually came from.  */
 196   if (NILP (Vinvocation_directory))
 197     {
 198       Lisp_Object found;
 199       int yes = openp (Vexec_path, Vinvocation_name,
 200                        EXEC_SUFFIXES, &found, 1);
 201       if (yes == 1)
 202         Vinvocation_directory = Ffile_name_directory (found);
 203     }
 204
 205   Vinstallation_directory = Qnil;
 206
 207   if (!NILP (Vinvocation_directory))
 208     {
 209       dir = Vinvocation_directory;
 210       name = Fexpand_file_name (Vinvocation_name, dir);
 211       while (1)
 212         {
 213           Lisp_Object tem, lisp_exists, lib_src_exists;
 214           Lisp_Object etc_exists, info_exists;
 215
 216           /* See if dir contains subdirs for use by Emacs.  */
 217           tem = Fexpand_file_name (build_string ("lisp"), dir);
 218           lisp_exists = Ffile_exists_p (tem);
 219           if (!NILP (lisp_exists))
 220             {
 221               tem = Fexpand_file_name (build_string ("lib-src"), dir);
 222               lib_src_exists = Ffile_exists_p (tem);
 223               if (!NILP (lib_src_exists))
 224                 {
 225                   tem = Fexpand_file_name (build_string ("etc"), dir);
 226                   etc_exists = Ffile_exists_p (tem);
 227                   if (!NILP (etc_exists))
 228                     {
 229                       tem = Fexpand_file_name (build_string ("info"), dir);
 230                       info_exists = Ffile_exists_p (tem);
 231                       if (!NILP (info_exists))
 232                         {
 233                           Vinstallation_directory
 234                             = Ffile_name_as_directory (dir);
 235                           break;
 236                         }
 237                     }
 238                 }
 239             }
 240
 241           /* See if dir's parent contains those subdirs.  */
 242           tem = Fexpand_file_name (build_string ("../lisp"), dir);
 243           lisp_exists = Ffile_exists_p (tem);
 244           if (!NILP (lisp_exists))
 245             {
 246               tem = Fexpand_file_name (build_string ("../lib-src"), dir);
 247               lib_src_exists = Ffile_exists_p (tem);
 248               if (!NILP (lib_src_exists))
 249                 {
 250                   tem = Fexpand_file_name (build_string ("../etc"), dir);
 251                   etc_exists = Ffile_exists_p (tem);
 252                   if (!NILP (etc_exists))
 253                     {
 254                       tem = Fexpand_file_name (build_string ("../info"), dir);
 255                       info_exists = Ffile_exists_p (tem);
 256                       if (!NILP (info_exists))
 257                         {
 258                           tem = Fexpand_file_name (build_string (".."), dir);
 259                           Vinstallation_directory
 260                             = Ffile_name_as_directory (tem);
 261                           break;
 262                         }
 263                     }
 264                 }
 265             }
 266
 267           /* If the Emacs executable is actually a link,
 268              next try the dir that the link points into.  */
 269           tem = Ffile_symlink_p (name);
 270           if (!NILP (tem))
 271             {
 272               name = tem;
 273               dir = Ffile_name_directory (name);
 274             }
 275           else
 276             break;
 277         }
 278     }
 279
 280   Vcommand_line_args = Qnil;
 281
 282   for (i = argc - 1; i >= 0; i--)
 283     {
 284       if (i == 0 || i > skip_args)
 285         Vcommand_line_args
 286           = Fcons (build_string (argv[i]), Vcommand_line_args);
 287     }
 288 }
 289
 290 DEFUN ("invocation-name", Finvocation_name, Sinvocation_name, 0, 0, 0,
 291   "Return the program name that was used to run Emacs.\n\
 292 Any directory names are omitted.")
 293   ()
 294 {
 295   return Fcopy_sequence (Vinvocation_name);
 296 }
 297
 298 DEFUN ("invocation-directory", Finvocation_directory, Sinvocation_directory,
 299   0, 0, 0,
 300   "Return the directory name in which the Emacs executable was located")
 301   ()
 302 {
 303   return Fcopy_sequence (Vinvocation_directory);
 304 }
 305
 306 \f
 307 #ifdef VMS
 308 #ifdef LINK_CRTL_SHARE
 309 #ifdef SHAREABLE_LIB_BUG
 310 extern noshare char **environ;
 311 #endif /* SHAREABLE_LIB_BUG */
 312 #endif /* LINK_CRTL_SHARE */
 313 #endif /* VMS */
 314
 315 #ifndef ORDINARY_LINK
 316 /* We don't include crtbegin.o and crtend.o in the link,
 317    so these functions and variables might be missed.
 318    Provide dummy definitions to avoid error.
 319    (We don't have any real constructors or destructors.)  */
 320 #ifdef __GNUC__
 321 #ifndef GCC_CTORS_IN_LIBC
 322 __do_global_ctors ()
 323 {}
 324 __do_global_ctors_aux ()
 325 {}
 326 __do_global_dtors ()
 327 {}
 328 /* Linux has a bug in its library; avoid an error.  */
 329 #ifndef LINUX
 330 char * __CTOR_LIST__[2] = { (char *) (-1), 0 };
 331 #endif
 332 char * __DTOR_LIST__[2] = { (char *) (-1), 0 };
 333 #endif /* GCC_CTORS_IN_LIBC */
 334 __main ()
 335 {}
 336 #endif /* __GNUC__ */
 337 #endif /* ORDINARY_LINK */
 338
 339 /* ARGSUSED */
 340 main (argc, argv, envp)
 341      int argc;
 342      char **argv;
 343      char **envp;
 344 {
 345   char stack_bottom_variable;
 346   int skip_args = 0;
 347   extern int errno;
 348   extern sys_nerr;
 349
 350 /* Map in shared memory, if we are using that.  */
 351 #ifdef HAVE_SHM
 352   if (argc > 1 && !strcmp (argv[1], "-nl"))
 353     {
 354       map_in_data (0);
 355       /* The shared memory was just restored, which clobbered this.  */
 356       skip_args = 1;
 357     }
 358   else
 359     {
 360       map_in_data (1);
 361       /* The shared memory was just restored, which clobbered this.  */
 362       skip_args = 0;
 363     }
 364 #endif
 365
 366 #ifdef NeXT
 367   extern int malloc_cookie;
 368
 369   /* This helps out unexnext.c.  */
 370   if (initialized)
 371     if (malloc_jumpstart (malloc_cookie) != 0)
 372       printf ("malloc jumpstart failed!\n");
 373 #endif /* NeXT */
 374
 375 #ifdef HAVE_X_WINDOWS
 376   /* Stupid kludge to catch command-line display spec.  We can't
 377      handle this argument entirely in window system dependent code
 378      because we don't even know which window system dependent code
 379      to run until we've recognized this argument.  */
 380   {
 381     int i;
 382
 383     for (i = 1; (i < argc && ! display_arg); i++)
 384       if (!strcmp (argv[i], "-d") || !strcmp (argv[i], "-display"))
 385         display_arg = 1;
 386   }
 387 #endif
 388
 389 #ifdef VMS
 390   /* If -map specified, map the data file in */
 391   if (argc > 2 && ! strcmp (argv[1], "-map"))
 392     {
 393       skip_args = 2;
 394       mapin_data (argv[2]);
 395     }
 396
 397 #ifdef LINK_CRTL_SHARE
 398 #ifdef SHAREABLE_LIB_BUG
 399   /* Bletcherous shared libraries! */
 400   if (!stdin)
 401     stdin = fdopen (0, "r");
 402   if (!stdout)
 403     stdout = fdopen (1, "w");
 404   if (!stderr)
 405     stderr = fdopen (2, "w");
 406   if (!environ)
 407     environ = envp;
 408 #endif /* SHAREABLE_LIB_BUG */
 409 #endif /* LINK_CRTL_SHARE */
 410 #endif /* VMS */
 411
 412   /* Record (approximately) where the stack begins.  */
 413   stack_bottom = &stack_bottom_variable;
 414
 415 #ifdef RUN_TIME_REMAP
 416   if (initialized)
 417     run_time_remap (argv[0]);
 418 #endif
 419
 420 #ifdef USG_SHARED_LIBRARIES
 421   if (bss_end)
 422     brk (bss_end);
 423 #endif
 424
 425   clearerr (stdin);
 426
 427 #ifdef BSD_PGRPS
 428   if (initialized)
 429     {
 430       inherited_pgroup = EMACS_GETPGRP (0);
 431       setpgrp (0, getpid ());
 432     }
 433 #else
 434 #if defined (USG5) && defined (INTERRUPT_INPUT)
 435   setpgrp ();
 436 #endif
 437 #endif
 438
 439
 440 #ifdef APOLLO
 441 #ifndef APOLLO_SR10
 442   /* If USE_DOMAIN_ACLS environment variable exists,
 443      use ACLs rather than UNIX modes. */
 444   if (egetenv ("USE_DOMAIN_ACLS"))
 445     default_acl (USE_DEFACL);
 446 #endif
 447 #endif /* APOLLO */
 448
 449 #ifndef SYSTEM_MALLOC
 450   if (! initialized)
 451     {
 452       /* Arrange to get warning messages as memory fills up.  */
 453       memory_warnings (0, malloc_warning);
 454
 455       /* Arrange to disable interrupt input while malloc and friends are
 456          running.  */
 457       uninterrupt_malloc ();
 458     }
 459 #endif  /* not SYSTEM_MALLOC */
 460
 461 #ifdef MSDOS
 462   /* We do all file input/output as binary files.  When we need to translate
 463      newlines, we do that manually.  */
 464   _fmode = O_BINARY;
 465   (stdin)->_flag &= ~_IOTEXT;
 466   (stdout)->_flag &= ~_IOTEXT;
 467   (stderr)->_flag &= ~_IOTEXT;
 468 #endif /* MSDOS */
 469
 470 #ifdef PRIO_PROCESS
 471   if (emacs_priority)
 472     nice (emacs_priority);
 473   setuid (getuid ());
 474 #endif /* PRIO_PROCESS */
 475
 476 #ifdef EXTRA_INITIALIZE
 477   EXTRA_INITIALIZE ();
 478 #endif
 479
 480   inhibit_window_system = 0;
 481
 482   /* Handle the -t switch, which specifies filename to use as terminal */
 483   if (skip_args + 2 < argc && !strcmp (argv[skip_args + 1], "-t"))
 484     {
 485       int result;
 486       skip_args += 2;
 487       close (0);
 488       close (1);
 489       result = open (argv[skip_args], O_RDWR, 2 );
 490       if (result < 0)
 491         {
 492           char *errstring = strerror (errno);
 493           fprintf (stderr, "emacs: %s: %s\n", argv[skip_args], errstring);
 494           exit (1);
 495         }
 496       dup (0);
 497       if (! isatty (0))
 498         {
 499           fprintf (stderr, "emacs: %s: not a tty\n", argv[skip_args]);
 500           exit (1);
 501         }
 502       fprintf (stderr, "Using %s\n", argv[skip_args]);
 503 #ifdef HAVE_X_WINDOWS
 504       inhibit_window_system = 1;        /* -t => -nw */
 505 #endif
 506     }
 507
 508   if (skip_args + 1 < argc
 509       && (!strcmp (argv[skip_args + 1], "-nw")))
 510     {
 511       skip_args += 1;
 512       inhibit_window_system = 1;
 513     }
 514
 515 /* Handle the -batch switch, which means don't do interactive display.  */
 516   noninteractive = 0;
 517   if (skip_args + 1 < argc && !strcmp (argv[skip_args + 1], "-batch"))
 518     {
 519       skip_args += 1;
 520       noninteractive = 1;
 521     }
 522
 523 #ifdef POSIX_SIGNALS
 524   init_signals ();
 525 #endif
 526
 527   if (
 528 #ifndef CANNOT_DUMP
 529       ! noninteractive || initialized
 530 #else
 531       1
 532 #endif
 533       )
 534     {
 535       /* Don't catch these signals in batch mode if not initialized.
 536          On some machines, this sets static data that would make
 537          signal fail to work right when the dumped Emacs is run.  */
 538       signal (SIGHUP, fatal_error_signal);
 539       signal (SIGQUIT, fatal_error_signal);
 540       signal (SIGILL, fatal_error_signal);
 541       signal (SIGTRAP, fatal_error_signal);
 542 #ifdef SIGIOT
 543       /* This is missing on some systems - OS/2, for example.  */
 544       signal (SIGIOT, fatal_error_signal);
 545 #endif
 546 #ifdef SIGEMT
 547       signal (SIGEMT, fatal_error_signal);
 548 #endif
 549       signal (SIGFPE, fatal_error_signal);
 550 #ifdef SIGBUS
 551       signal (SIGBUS, fatal_error_signal);
 552 #endif
 553       signal (SIGSEGV, fatal_error_signal);
 554 #ifdef SIGSYS
 555       signal (SIGSYS, fatal_error_signal);
 556 #endif
 557       signal (SIGTERM, fatal_error_signal);
 558 #ifdef SIGXCPU
 559       signal (SIGXCPU, fatal_error_signal);
 560 #endif
 561 #ifdef SIGXFSZ
 562       signal (SIGXFSZ, fatal_error_signal);
 563 #endif /* SIGXFSZ */
 564
 565 #ifdef SIGDANGER
 566       /* This just means available memory is getting low.  */
 567       signal (SIGDANGER, memory_warning_signal);
 568 #endif
 569
 570 #ifdef AIX
 571 /* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU.  */
 572       signal (SIGXCPU, fatal_error_signal);
 573 #ifndef _I386
 574       signal (SIGIOINT, fatal_error_signal);
 575 #endif
 576       signal (SIGGRANT, fatal_error_signal);
 577       signal (SIGRETRACT, fatal_error_signal);
 578       signal (SIGSOUND, fatal_error_signal);
 579       signal (SIGMSG, fatal_error_signal);
 580 #endif /* AIX */
 581     }
 582
 583   noninteractive1 = noninteractive;
 584
 585 /* Perform basic initializations (not merely interning symbols) */
 586
 587   if (!initialized)
 588     {
 589       init_alloc_once ();
 590       init_obarray ();
 591       init_eval_once ();
 592       init_syntax_once ();      /* Create standard syntax table.  */
 593                       /* Must be done before init_buffer */
 594       init_casetab_once ();
 595       init_buffer_once ();      /* Create buffer table and some buffers */
 596       init_minibuf_once ();     /* Create list of minibuffers */
 597                               /* Must precede init_window_once */
 598       init_window_once ();      /* Init the window system */
 599     }
 600
 601   init_alloc ();
 602   init_eval ();
 603   init_data ();
 604
 605 #ifdef MSDOS
 606   /* Call early 'cause init_environment needs it.  */
 607   init_dosfns ();
 608   /* Set defaults for several environment variables.  */
 609   if (initialized) init_environment (argc, argv, skip_args);
 610 #endif
 611
 612   /* egetenv is a pretty low-level facility, which may get called in
 613      many circumstances; it seems flimsy to put off initializing it
 614      until calling init_callproc.  */
 615   set_process_environment ();
 616   /* AIX crashes are reported in system versions 3.2.3 and 3.2.4
 617      if this is not done.  Do it after set_process_environment so that we
 618      don't pollute Vprocess_environment.  */
 619 #ifdef AIX
 620   putenv ("LANG=C");
 621 #endif
 622
 623   init_buffer ();       /* Init default directory of main buffer */
 624
 625   init_callproc_1 ();   /* Must precede init_cmdargs and init_sys_modes.  */
 626   init_cmdargs (argc, argv, skip_args); /* Must precede init_lread.  */
 627   init_callproc ();     /* Must follow init_cmdargs but not init_sys_modes.  */
 628   init_lread ();
 629
 630   if (!noninteractive)
 631     {
 632 #ifdef VMS
 633       init_vms_input ();/* init_display calls get_frame_size, that needs this */
 634 #endif /* VMS */
 635       init_display ();  /* Determine terminal type.  init_sys_modes uses results */
 636     }
 637   init_keyboard ();     /* This too must precede init_sys_modes */
 638 #ifdef VMS
 639   init_vmsproc ();      /* And this too. */
 640 #endif /* VMS */
 641   init_sys_modes ();    /* Init system terminal modes (RAW or CBREAK, etc.) */
 642   init_xdisp ();
 643   init_macros ();
 644   init_editfns ();
 645 #ifdef LISP_FLOAT_TYPE
 646   init_floatfns ();
 647 #endif
 648 #ifdef VMS
 649   init_vmsfns ();
 650 #endif /* VMS */
 651   init_process ();
 652 #ifdef CLASH_DETECTION
 653   init_filelock ();
 654 #endif /* CLASH_DETECTION */
 655
 656 /* Intern the names of all standard functions and variables; define standard keys */
 657
 658   if (!initialized)
 659     {
 660       /* The basic levels of Lisp must come first */
 661       /* And data must come first of all
 662          for the sake of symbols like error-message */
 663       syms_of_data ();
 664       syms_of_alloc ();
 665       syms_of_lread ();
 666       syms_of_print ();
 667       syms_of_eval ();
 668       syms_of_fns ();
 669       syms_of_floatfns ();
 670
 671       syms_of_abbrev ();
 672       syms_of_buffer ();
 673       syms_of_bytecode ();
 674       syms_of_callint ();
 675       syms_of_casefiddle ();
 676       syms_of_casetab ();
 677       syms_of_callproc ();
 678       syms_of_cmds ();
 679 #ifndef NO_DIR_LIBRARY
 680       syms_of_dired ();
 681 #endif /* not NO_DIR_LIBRARY */
 682       syms_of_display ();
 683       syms_of_doc ();
 684       syms_of_editfns ();
 685       syms_of_emacs ();
 686       syms_of_fileio ();
 687 #ifdef CLASH_DETECTION
 688       syms_of_filelock ();
 689 #endif /* CLASH_DETECTION */
 690       syms_of_indent ();
 691       syms_of_keyboard ();
 692       syms_of_keymap ();
 693       syms_of_macros ();
 694       syms_of_marker ();
 695       syms_of_minibuf ();
 696       syms_of_mocklisp ();
 697       syms_of_process ();
 698       syms_of_search ();
 699       syms_of_frame ();
 700       syms_of_syntax ();
 701       syms_of_term ();
 702       syms_of_undo ();
 703
 704       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
 705       syms_of_textprop ();
 706 #ifdef VMS
 707       syms_of_vmsproc ();
 708 #endif /* VMS */
 709       syms_of_window ();
 710       syms_of_xdisp ();
 711 #ifdef HAVE_X_WINDOWS
 712       syms_of_xterm ();
 713       syms_of_xfns ();
 714       syms_of_xfaces ();
 715 #ifdef HAVE_X11
 716       syms_of_xselect ();
 717 #endif
 718 #ifdef HAVE_X_MENU
 719       syms_of_xmenu ();
 720 #endif /* HAVE_X_MENU */
 721 #endif /* HAVE_X_WINDOWS */
 722
 723 #ifdef SYMS_SYSTEM
 724       SYMS_SYSTEM;
 725 #endif
 726
 727 #ifdef SYMS_MACHINE
 728       SYMS_MACHINE;
 729 #endif
 730
 731       keys_of_casefiddle ();
 732       keys_of_cmds ();
 733       keys_of_buffer ();
 734       keys_of_keyboard ();
 735       keys_of_keymap ();
 736       keys_of_macros ();
 737       keys_of_minibuf ();
 738       keys_of_window ();
 739       keys_of_frame ();
 740     }
 741
 742   if (!initialized)
 743     {
 744       /* Handle -l loadup-and-dump, args passed by Makefile. */
 745       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
 746         Vtop_level = Fcons (intern ("load"),
 747                             Fcons (build_string (argv[2 + skip_args]), Qnil));
 748 #ifdef CANNOT_DUMP
 749       /* Unless next switch is -nl, load "loadup.el" first thing.  */
 750       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
 751         Vtop_level = Fcons (intern ("load"),
 752                             Fcons (build_string ("loadup.el"), Qnil));
 753 #endif /* CANNOT_DUMP */
 754     }
 755
 756   initialized = 1;
 757
 758 #if defined (sun) || defined (LOCALTIME_CACHE)
 759   /* sun's localtime has a bug.  it caches the value of the time
 760      zone rather than looking it up every time.  Since localtime() is
 761      called to bolt the undumping time into the undumped emacs, this
 762      results in localtime ignoring the TZ environment variable.
 763      This flushes the new TZ value into localtime. */
 764   tzset ();
 765 #endif /* defined (sun) || defined (LOCALTIME_CACHE) */
 766
 767   /* Enter editor command loop.  This never returns.  */
 768   Frecursive_edit ();
 769   /* NOTREACHED */
 770 }
 771 \f
 772 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
 773   "Exit the Emacs job and kill it.\n\
 774 If ARG is an integer, return ARG as the exit program code.\n\
 775 If ARG is a  string, stuff it as keyboard input.\n\n\
 776 The value of `kill-emacs-hook', if not void,\n\
 777 is a list of functions (of no args),\n\
 778 all of which are called before Emacs is actually killed.")
 779   (arg)
 780      Lisp_Object arg;
 781 {
 782   Lisp_Object hook, hook1;
 783   int i;
 784   struct gcpro gcpro1;
 785
 786   GCPRO1 (arg);
 787
 788   if (feof (stdin))
 789     arg = Qt;
 790
 791   if (!NILP (Vrun_hooks) && !noninteractive)
 792     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
 793
 794   UNGCPRO;
 795
 796 /* Is it really necessary to do this deassign
 797    when we are going to exit anyway?  */
 798 /* #ifdef VMS
 799   stop_vms_input ();
 800  #endif  */
 801
 802   shut_down_emacs (0, 0, STRINGP (arg) ? arg : Qnil);
 803
 804   exit ((XTYPE (arg) == Lisp_Int) ? XINT (arg)
 805 #ifdef VMS
 806         : 1
 807 #else
 808         : 0
 809 #endif
 810         );
 811   /* NOTREACHED */
 812 }
 813
 814
 815 /* Perform an orderly shutdown of Emacs.  Autosave any modified
 816    buffers, kill any child processes, clean up the terminal modes (if
 817    we're in the foreground), and other stuff like that.  Don't perform
 818    any redisplay; this may be called when Emacs is shutting down in
 819    the background, or after its X connection has died.
 820
 821    If SIG is a signal number, print a message for it.
 822
 823    This is called by fatal signal handlers, X protocol error handlers,
 824    and Fkill_emacs.  */
 825
 826 void
 827 shut_down_emacs (sig, no_x, stuff)
 828      int sig, no_x;
 829      Lisp_Object stuff;
 830 {
 831   /* Prevent running of hooks from now on.  */
 832   Vrun_hooks = Qnil;
 833
 834   /* If we are controlling the terminal, reset terminal modes */
 835 #ifdef EMACS_HAVE_TTY_PGRP
 836   {
 837     int pgrp = EMACS_GETPGRP (0);
 838
 839     int tpgrp;
 840     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
 841         && tpgrp == pgrp)
 842       {
 843         fflush (stdout);
 844         reset_sys_modes ();
 845         if (sig && sig != SIGTERM)
 846           fprintf (stderr, "Fatal error (%d).", sig);
 847       }
 848   }
 849 #else
 850   fflush (stdout);
 851   reset_sys_modes ();
 852 #endif
 853
 854   stuff_buffered_input (stuff);
 855
 856   kill_buffer_processes (Qnil);
 857   Fdo_auto_save (Qt, Qnil);
 858
 859 #ifdef CLASH_DETECTION
 860   unlock_all_files ();
 861 #endif
 862
 863 #ifdef VMS
 864   kill_vms_processes ();
 865 #endif
 866
 867 #ifdef HAVE_X_WINDOWS
 868   if (!noninteractive && EQ (Vwindow_system, intern ("x")) && ! no_x)
 869     Fx_close_current_connection ();
 870 #endif /* HAVE_X_WINDOWS */
 871
 872 #ifdef SIGIO
 873   /* There is a tendency for a SIGIO signal to arrive within exit,
 874      and cause a SIGHUP because the input descriptor is already closed.  */
 875   unrequest_sigio ();
 876   signal (SIGIO, SIG_IGN);
 877 #endif
 878 }
 879
 880
 881 \f
 882 #ifndef CANNOT_DUMP
 883 /* Nothing like this can be implemented on an Apollo.
 884    What a loss!  */
 885
 886 #ifdef HAVE_SHM
 887
 888 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
 889   "Dump current state of Emacs into data file FILENAME.\n\
 890 This function exists on systems that use HAVE_SHM.")
 891   (intoname)
 892      Lisp_Object intoname;
 893 {
 894   extern int my_edata;
 895   Lisp_Object tem;
 896
 897   CHECK_STRING (intoname, 0);
 898   intoname = Fexpand_file_name (intoname, Qnil);
 899
 900   tem = Vpurify_flag;
 901   Vpurify_flag = Qnil;
 902
 903   fflush (stdout);
 904   /* Tell malloc where start of impure now is */
 905   /* Also arrange for warnings when nearly out of space.  */
 906 #ifndef SYSTEM_MALLOC
 907   memory_warnings (&my_edata, malloc_warning);
 908 #endif
 909   map_out_data (XSTRING (intoname)->data);
 910
 911   Vpurify_flag = tem;
 912
 913   return Qnil;
 914 }
 915
 916 #else /* not HAVE_SHM */
 917
 918 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
 919   "Dump current state of Emacs into executable file FILENAME.\n\
 920 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
 921 This is used in the file `loadup.el' when building Emacs.\n\
 922 \n\
 923 Bind `command-line-processed' to nil before dumping,\n\
 924 if you want the dumped Emacs to process its command line\n\
 925 and announce itself normally when it is run.")
 926   (intoname, symname)
 927      Lisp_Object intoname, symname;
 928 {
 929   extern int my_edata;
 930   Lisp_Object tem;
 931
 932   CHECK_STRING (intoname, 0);
 933   intoname = Fexpand_file_name (intoname, Qnil);
 934   if (!NILP (symname))
 935     {
 936       CHECK_STRING (symname, 0);
 937       if (XSTRING (symname)->size)
 938         symname = Fexpand_file_name (symname, Qnil);
 939     }
 940
 941   tem = Vpurify_flag;
 942   Vpurify_flag = Qnil;
 943
 944   fflush (stdout);
 945 #ifdef VMS
 946   mapout_data (XSTRING (intoname)->data);
 947 #else
 948   /* Tell malloc where start of impure now is */
 949   /* Also arrange for warnings when nearly out of space.  */
 950 #ifndef SYSTEM_MALLOC
 951   memory_warnings (&my_edata, malloc_warning);
 952 #endif
 953   unexec (XSTRING (intoname)->data,
 954           !NILP (symname) ? XSTRING (symname)->data : 0, &my_edata, 0, 0);
 955 #endif /* not VMS */
 956
 957   Vpurify_flag = tem;
 958
 959   return Qnil;
 960 }
 961
 962 #endif /* not HAVE_SHM */
 963
 964 #endif /* not CANNOT_DUMP */
 965 \f
 966 #ifndef SEPCHAR
 967 #define SEPCHAR ':'
 968 #endif
 969
 970 Lisp_Object
 971 decode_env_path (evarname, defalt)
 972      char *evarname, *defalt;
 973 {
 974   register char *path, *p;
 975
 976   Lisp_Object lpath;
 977
 978   /* It's okay to use getenv here, because this function is only used
 979      to initialize variables when Emacs starts up, and isn't called
 980      after that.  */
 981   if (evarname != 0)
 982     path = (char *) getenv (evarname);
 983   else
 984     path = 0;
 985   if (!path)
 986     path = defalt;
 987   lpath = Qnil;
 988   while (1)
 989     {
 990       p = index (path, SEPCHAR);
 991       if (!p) p = path + strlen (path);
 992       lpath = Fcons (p - path ? make_string (path, p - path) : Qnil,
 993                      lpath);
 994       if (*p)
 995         path = p + 1;
 996       else
 997         break;
 998     }
 999   return Fnreverse (lpath);
1000 }
1001
1002 syms_of_emacs ()
1003 {
1004 #ifndef CANNOT_DUMP
1005 #ifdef HAVE_SHM
1006   defsubr (&Sdump_emacs_data);
1007 #else
1008   defsubr (&Sdump_emacs);
1009 #endif
1010 #endif
1011
1012   defsubr (&Skill_emacs);
1013
1014   defsubr (&Sinvocation_name);
1015   defsubr (&Sinvocation_directory);
1016
1017   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
1018     "Args passed by shell to Emacs, as a list of strings.");
1019
1020   DEFVAR_LISP ("system-type", &Vsystem_type,
1021     "Value is symbol indicating type of operating system you are using.");
1022   Vsystem_type = intern (SYSTEM_TYPE);
1023
1024   DEFVAR_LISP ("system-configuration", &Vsystem_configuration,
1025     "Value is string indicating configuration Emacs was built for.");
1026   Vsystem_configuration = build_string (CONFIGURATION);
1027
1028   DEFVAR_BOOL ("noninteractive", &noninteractive1,
1029     "Non-nil means Emacs is running without interactive terminal.");
1030
1031   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
1032     "Hook to be run whenever kill-emacs is called.\n\
1033 Since kill-emacs may be invoked when the terminal is disconnected (or\n\
1034 in other similar situations), functions placed on this hook should not\n\
1035 expect to be able to interact with the user.");
1036   Vkill_emacs_hook = Qnil;
1037
1038   DEFVAR_INT ("emacs-priority", &emacs_priority,
1039     "Priority for Emacs to run at.\n\
1040 This value is effective only if set before Emacs is dumped,\n\
1041 and only if the Emacs executable is installed with setuid to permit\n\
1042 it to change priority.  (Emacs sets its uid back to the real uid.)");
1043   emacs_priority = 0;
1044
1045   staticpro (&Vinstallation_directory);
1046   Vinstallation_directory = Qnil;
1047
1048   /* These have already been set, in init_cmdargs, so don't set them here.  */
1049   staticpro (&Vinvocation_name);
1050   staticpro (&Vinvocation_directory);
1051 }