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