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   inhibit_window_system = 0;
 477
 478   /* Handle the -t switch, which specifies filename to use as terminal */
 479   if (skip_args + 2 < argc && !strcmp (argv[skip_args + 1], "-t"))
 480     {
 481       int result;
 482       skip_args += 2;
 483       close (0);
 484       close (1);
 485       result = open (argv[skip_args], O_RDWR, 2 );
 486       if (result < 0)
 487         {
 488           char *errstring = strerror (errno);
 489           fprintf (stderr, "emacs: %s: %s\n", argv[skip_args], errstring);
 490           exit (1);
 491         }
 492       dup (0);
 493       if (! isatty (0))
 494         {
 495           fprintf (stderr, "emacs: %s: not a tty\n", argv[skip_args]);
 496           exit (1);
 497         }
 498       fprintf (stderr, "Using %s\n", argv[skip_args]);
 499 #ifdef HAVE_X_WINDOWS
 500       inhibit_window_system = 1;        /* -t => -nw */
 501 #endif
 502     }
 503
 504   if (skip_args + 1 < argc
 505       && (!strcmp (argv[skip_args + 1], "-nw")))
 506     {
 507       skip_args += 1;
 508       inhibit_window_system = 1;
 509     }
 510
 511 /* Handle the -batch switch, which means don't do interactive display.  */
 512   noninteractive = 0;
 513   if (skip_args + 1 < argc && !strcmp (argv[skip_args + 1], "-batch"))
 514     {
 515       skip_args += 1;
 516       noninteractive = 1;
 517     }
 518
 519 #ifdef POSIX_SIGNALS
 520   init_signals ();
 521 #endif
 522
 523   if (
 524 #ifndef CANNOT_DUMP
 525       ! noninteractive || initialized
 526 #else
 527       1
 528 #endif
 529       )
 530     {
 531       /* Don't catch these signals in batch mode if not initialized.
 532          On some machines, this sets static data that would make
 533          signal fail to work right when the dumped Emacs is run.  */
 534       signal (SIGHUP, fatal_error_signal);
 535       signal (SIGQUIT, fatal_error_signal);
 536       signal (SIGILL, fatal_error_signal);
 537       signal (SIGTRAP, fatal_error_signal);
 538 #ifdef SIGIOT
 539       /* This is missing on some systems - OS/2, for example.  */
 540       signal (SIGIOT, fatal_error_signal);
 541 #endif
 542 #ifdef SIGEMT
 543       signal (SIGEMT, fatal_error_signal);
 544 #endif
 545       signal (SIGFPE, fatal_error_signal);
 546 #ifdef SIGBUS
 547       signal (SIGBUS, fatal_error_signal);
 548 #endif
 549       signal (SIGSEGV, fatal_error_signal);
 550 #ifdef SIGSYS
 551       signal (SIGSYS, fatal_error_signal);
 552 #endif
 553       signal (SIGTERM, fatal_error_signal);
 554 #ifdef SIGXCPU
 555       signal (SIGXCPU, fatal_error_signal);
 556 #endif
 557 #ifdef SIGXFSZ
 558       signal (SIGXFSZ, fatal_error_signal);
 559 #endif /* SIGXFSZ */
 560
 561 #ifdef SIGDANGER
 562       /* This just means available memory is getting low.  */
 563       signal (SIGDANGER, memory_warning_signal);
 564 #endif
 565
 566 #ifdef AIX
 567 /* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU.  */
 568       signal (SIGXCPU, fatal_error_signal);
 569 #ifndef _I386
 570       signal (SIGIOINT, fatal_error_signal);
 571 #endif
 572       signal (SIGGRANT, fatal_error_signal);
 573       signal (SIGRETRACT, fatal_error_signal);
 574       signal (SIGSOUND, fatal_error_signal);
 575       signal (SIGMSG, fatal_error_signal);
 576 #endif /* AIX */
 577     }
 578
 579   noninteractive1 = noninteractive;
 580
 581 /* Perform basic initializations (not merely interning symbols) */
 582
 583   if (!initialized)
 584     {
 585       init_alloc_once ();
 586       init_obarray ();
 587       init_eval_once ();
 588       init_syntax_once ();      /* Create standard syntax table.  */
 589                       /* Must be done before init_buffer */
 590       init_casetab_once ();
 591       init_buffer_once ();      /* Create buffer table and some buffers */
 592       init_minibuf_once ();     /* Create list of minibuffers */
 593                               /* Must precede init_window_once */
 594       init_window_once ();      /* Init the window system */
 595     }
 596
 597   init_alloc ();
 598   init_eval ();
 599   init_data ();
 600
 601 #ifdef MSDOS
 602   /* Call early 'cause init_environment needs it.  */
 603   init_dosfns ();
 604   /* Set defaults for several environment variables.  */
 605   if (initialized) init_environment (argc, argv, skip_args);
 606 #endif
 607
 608   /* egetenv is a pretty low-level facility, which may get called in
 609      many circumstances; it seems flimsy to put off initializing it
 610      until calling init_callproc.  */
 611   set_process_environment ();
 612   /* AIX crashes are reported in system versions 3.2.3 and 3.2.4
 613      if this is not done.  Do it after set_process_environment so that we
 614      don't pollute Vprocess_environment.  */
 615 #ifdef AIX
 616   putenv ("LANG=C");
 617 #endif
 618
 619   init_buffer ();       /* Init default directory of main buffer */
 620
 621   init_callproc_1 ();   /* Must precede init_cmdargs and init_sys_modes.  */
 622   init_cmdargs (argc, argv, skip_args); /* Must precede init_lread.  */
 623   init_callproc ();     /* Must follow init_cmdargs but not init_sys_modes.  */
 624   init_lread ();
 625
 626   if (!noninteractive)
 627     {
 628 #ifdef VMS
 629       init_vms_input ();/* init_display calls get_frame_size, that needs this */
 630 #endif /* VMS */
 631       init_display ();  /* Determine terminal type.  init_sys_modes uses results */
 632     }
 633   init_keyboard ();     /* This too must precede init_sys_modes */
 634 #ifdef VMS
 635   init_vmsproc ();      /* And this too. */
 636 #endif /* VMS */
 637   init_sys_modes ();    /* Init system terminal modes (RAW or CBREAK, etc.) */
 638   init_xdisp ();
 639   init_macros ();
 640   init_editfns ();
 641 #ifdef LISP_FLOAT_TYPE
 642   init_floatfns ();
 643 #endif
 644 #ifdef VMS
 645   init_vmsfns ();
 646 #endif /* VMS */
 647   init_process ();
 648 #ifdef CLASH_DETECTION
 649   init_filelock ();
 650 #endif /* CLASH_DETECTION */
 651
 652 /* Intern the names of all standard functions and variables; define standard keys */
 653
 654   if (!initialized)
 655     {
 656       /* The basic levels of Lisp must come first */
 657       /* And data must come first of all
 658          for the sake of symbols like error-message */
 659       syms_of_data ();
 660       syms_of_alloc ();
 661       syms_of_lread ();
 662       syms_of_print ();
 663       syms_of_eval ();
 664       syms_of_fns ();
 665       syms_of_floatfns ();
 666
 667       syms_of_abbrev ();
 668       syms_of_buffer ();
 669       syms_of_bytecode ();
 670       syms_of_callint ();
 671       syms_of_casefiddle ();
 672       syms_of_casetab ();
 673       syms_of_callproc ();
 674       syms_of_cmds ();
 675 #ifndef NO_DIR_LIBRARY
 676       syms_of_dired ();
 677 #endif /* not NO_DIR_LIBRARY */
 678       syms_of_display ();
 679       syms_of_doc ();
 680       syms_of_editfns ();
 681       syms_of_emacs ();
 682       syms_of_fileio ();
 683 #ifdef CLASH_DETECTION
 684       syms_of_filelock ();
 685 #endif /* CLASH_DETECTION */
 686       syms_of_indent ();
 687       syms_of_keyboard ();
 688       syms_of_keymap ();
 689       syms_of_macros ();
 690       syms_of_marker ();
 691       syms_of_minibuf ();
 692       syms_of_mocklisp ();
 693       syms_of_process ();
 694       syms_of_search ();
 695       syms_of_frame ();
 696       syms_of_syntax ();
 697       syms_of_undo ();
 698
 699       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
 700       syms_of_textprop ();
 701 #ifdef VMS
 702       syms_of_vmsproc ();
 703 #endif /* VMS */
 704       syms_of_window ();
 705       syms_of_xdisp ();
 706 #ifdef HAVE_X_WINDOWS
 707       syms_of_xterm ();
 708       syms_of_xfns ();
 709       syms_of_xfaces ();
 710 #ifdef HAVE_X11
 711       syms_of_xselect ();
 712 #endif
 713 #ifdef HAVE_X_MENU
 714       syms_of_xmenu ();
 715 #endif /* HAVE_X_MENU */
 716 #endif /* HAVE_X_WINDOWS */
 717
 718 #ifdef SYMS_SYSTEM
 719       SYMS_SYSTEM;
 720 #endif
 721
 722 #ifdef SYMS_MACHINE
 723       SYMS_MACHINE;
 724 #endif
 725
 726       keys_of_casefiddle ();
 727       keys_of_cmds ();
 728       keys_of_buffer ();
 729       keys_of_keyboard ();
 730       keys_of_keymap ();
 731       keys_of_macros ();
 732       keys_of_minibuf ();
 733       keys_of_window ();
 734       keys_of_frame ();
 735     }
 736
 737   if (!initialized)
 738     {
 739       /* Handle -l loadup-and-dump, args passed by Makefile. */
 740       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
 741         Vtop_level = Fcons (intern ("load"),
 742                             Fcons (build_string (argv[2 + skip_args]), Qnil));
 743 #ifdef CANNOT_DUMP
 744       /* Unless next switch is -nl, load "loadup.el" first thing.  */
 745       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
 746         Vtop_level = Fcons (intern ("load"),
 747                             Fcons (build_string ("loadup.el"), Qnil));
 748 #endif /* CANNOT_DUMP */
 749     }
 750
 751   initialized = 1;
 752
 753 #if defined (sun) || defined (LOCALTIME_CACHE)
 754   /* sun's localtime has a bug.  it caches the value of the time
 755      zone rather than looking it up every time.  Since localtime() is
 756      called to bolt the undumping time into the undumped emacs, this
 757      results in localtime ignoring the TZ environment variable.
 758      This flushes the new TZ value into localtime. */
 759   tzset ();
 760 #endif /* defined (sun) || defined (LOCALTIME_CACHE) */
 761
 762   /* Enter editor command loop.  This never returns.  */
 763   Frecursive_edit ();
 764   /* NOTREACHED */
 765 }
 766 \f
 767 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
 768   "Exit the Emacs job and kill it.\n\
 769 If ARG is an integer, return ARG as the exit program code.\n\
 770 If ARG is a  string, stuff it as keyboard input.\n\n\
 771 The value of `kill-emacs-hook', if not void,\n\
 772 is a list of functions (of no args),\n\
 773 all of which are called before Emacs is actually killed.")
 774   (arg)
 775      Lisp_Object arg;
 776 {
 777   Lisp_Object hook, hook1;
 778   int i;
 779   struct gcpro gcpro1;
 780
 781   GCPRO1 (arg);
 782
 783   if (feof (stdin))
 784     arg = Qt;
 785
 786   if (!NILP (Vrun_hooks) && !noninteractive)
 787     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
 788
 789   UNGCPRO;
 790
 791 /* Is it really necessary to do this deassign
 792    when we are going to exit anyway?  */
 793 /* #ifdef VMS
 794   stop_vms_input ();
 795  #endif  */
 796
 797   shut_down_emacs (0, 0, STRINGP (arg) ? arg : Qnil);
 798
 799   exit ((XTYPE (arg) == Lisp_Int) ? XINT (arg)
 800 #ifdef VMS
 801         : 1
 802 #else
 803         : 0
 804 #endif
 805         );
 806   /* NOTREACHED */
 807 }
 808
 809
 810 /* Perform an orderly shutdown of Emacs.  Autosave any modified
 811    buffers, kill any child processes, clean up the terminal modes (if
 812    we're in the foreground), and other stuff like that.  Don't perform
 813    any redisplay; this may be called when Emacs is shutting down in
 814    the background, or after its X connection has died.
 815
 816    If SIG is a signal number, print a message for it.
 817
 818    This is called by fatal signal handlers, X protocol error handlers,
 819    and Fkill_emacs.  */
 820
 821 void
 822 shut_down_emacs (sig, no_x, stuff)
 823      int sig, no_x;
 824      Lisp_Object stuff;
 825 {
 826   /* Prevent running of hooks from now on.  */
 827   Vrun_hooks = Qnil;
 828
 829   /* If we are controlling the terminal, reset terminal modes */
 830 #ifdef EMACS_HAVE_TTY_PGRP
 831   {
 832     int pgrp = EMACS_GETPGRP (0);
 833
 834     int tpgrp;
 835     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
 836         && tpgrp == pgrp)
 837       {
 838         fflush (stdout);
 839         reset_sys_modes ();
 840         if (sig && sig != SIGTERM)
 841           fprintf (stderr, "Fatal error (%d).", sig);
 842       }
 843   }
 844 #else
 845   fflush (stdout);
 846   reset_sys_modes ();
 847 #endif
 848
 849   stuff_buffered_input (stuff);
 850
 851   kill_buffer_processes (Qnil);
 852   Fdo_auto_save (Qt, Qnil);
 853
 854 #ifdef CLASH_DETECTION
 855   unlock_all_files ();
 856 #endif
 857
 858 #ifdef VMS
 859   kill_vms_processes ();
 860 #endif
 861
 862 #ifdef HAVE_X_WINDOWS
 863   if (!noninteractive && EQ (Vwindow_system, intern ("x")) && ! no_x)
 864     Fx_close_current_connection ();
 865 #endif /* HAVE_X_WINDOWS */
 866
 867 #ifdef SIGIO
 868   /* There is a tendency for a SIGIO signal to arrive within exit,
 869      and cause a SIGHUP because the input descriptor is already closed.  */
 870   unrequest_sigio ();
 871   signal (SIGIO, SIG_IGN);
 872 #endif
 873 }
 874
 875
 876 \f
 877 #ifndef CANNOT_DUMP
 878 /* Nothing like this can be implemented on an Apollo.
 879    What a loss!  */
 880
 881 #ifdef HAVE_SHM
 882
 883 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
 884   "Dump current state of Emacs into data file FILENAME.\n\
 885 This function exists on systems that use HAVE_SHM.")
 886   (intoname)
 887      Lisp_Object intoname;
 888 {
 889   extern int my_edata;
 890   Lisp_Object tem;
 891
 892   CHECK_STRING (intoname, 0);
 893   intoname = Fexpand_file_name (intoname, Qnil);
 894
 895   tem = Vpurify_flag;
 896   Vpurify_flag = Qnil;
 897
 898   fflush (stdout);
 899   /* Tell malloc where start of impure now is */
 900   /* Also arrange for warnings when nearly out of space.  */
 901 #ifndef SYSTEM_MALLOC
 902   memory_warnings (&my_edata, malloc_warning);
 903 #endif
 904   map_out_data (XSTRING (intoname)->data);
 905
 906   Vpurify_flag = tem;
 907
 908   return Qnil;
 909 }
 910
 911 #else /* not HAVE_SHM */
 912
 913 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
 914   "Dump current state of Emacs into executable file FILENAME.\n\
 915 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
 916 This is used in the file `loadup.el' when building Emacs.\n\
 917 \n\
 918 Bind `command-line-processed' to nil before dumping,\n\
 919 if you want the dumped Emacs to process its command line\n\
 920 and announce itself normally when it is run.")
 921   (intoname, symname)
 922      Lisp_Object intoname, symname;
 923 {
 924   extern int my_edata;
 925   Lisp_Object tem;
 926
 927   CHECK_STRING (intoname, 0);
 928   intoname = Fexpand_file_name (intoname, Qnil);
 929   if (!NILP (symname))
 930     {
 931       CHECK_STRING (symname, 0);
 932       if (XSTRING (symname)->size)
 933         symname = Fexpand_file_name (symname, Qnil);
 934     }
 935
 936   tem = Vpurify_flag;
 937   Vpurify_flag = Qnil;
 938
 939   fflush (stdout);
 940 #ifdef VMS
 941   mapout_data (XSTRING (intoname)->data);
 942 #else
 943   /* Tell malloc where start of impure now is */
 944   /* Also arrange for warnings when nearly out of space.  */
 945 #ifndef SYSTEM_MALLOC
 946   memory_warnings (&my_edata, malloc_warning);
 947 #endif
 948   unexec (XSTRING (intoname)->data,
 949           !NILP (symname) ? XSTRING (symname)->data : 0, &my_edata, 0, 0);
 950 #endif /* not VMS */
 951
 952   Vpurify_flag = tem;
 953
 954   return Qnil;
 955 }
 956
 957 #endif /* not HAVE_SHM */
 958
 959 #endif /* not CANNOT_DUMP */
 960 \f
 961 #ifndef SEPCHAR
 962 #define SEPCHAR ':'
 963 #endif
 964
 965 Lisp_Object
 966 decode_env_path (evarname, defalt)
 967      char *evarname, *defalt;
 968 {
 969   register char *path, *p;
 970
 971   Lisp_Object lpath;
 972
 973   /* It's okay to use getenv here, because this function is only used
 974      to initialize variables when Emacs starts up, and isn't called
 975      after that.  */
 976   if (evarname != 0)
 977     path = (char *) getenv (evarname);
 978   else
 979     path = 0;
 980   if (!path)
 981     path = defalt;
 982   lpath = Qnil;
 983   while (1)
 984     {
 985       p = index (path, SEPCHAR);
 986       if (!p) p = path + strlen (path);
 987       lpath = Fcons (p - path ? make_string (path, p - path) : Qnil,
 988                      lpath);
 989       if (*p)
 990         path = p + 1;
 991       else
 992         break;
 993     }
 994   return Fnreverse (lpath);
 995 }
 996
 997 syms_of_emacs ()
 998 {
 999 #ifndef CANNOT_DUMP
1000 #ifdef HAVE_SHM
1001   defsubr (&Sdump_emacs_data);
1002 #else
1003   defsubr (&Sdump_emacs);
1004 #endif
1005 #endif
1006
1007   defsubr (&Skill_emacs);
1008
1009   defsubr (&Sinvocation_name);
1010   defsubr (&Sinvocation_directory);
1011
1012   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
1013     "Args passed by shell to Emacs, as a list of strings.");
1014
1015   DEFVAR_LISP ("system-type", &Vsystem_type,
1016     "Value is symbol indicating type of operating system you are using.");
1017   Vsystem_type = intern (SYSTEM_TYPE);
1018
1019   DEFVAR_LISP ("system-configuration", &Vsystem_configuration,
1020     "Value is string indicating configuration Emacs was built for.");
1021   Vsystem_configuration = build_string (CONFIGURATION);
1022
1023   DEFVAR_BOOL ("noninteractive", &noninteractive1,
1024     "Non-nil means Emacs is running without interactive terminal.");
1025
1026   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
1027     "Hook to be run whenever kill-emacs is called.\n\
1028 Since kill-emacs may be invoked when the terminal is disconnected (or\n\
1029 in other similar situations), functions placed on this hook should not\n\
1030 expect to be able to interact with the user.");
1031   Vkill_emacs_hook = Qnil;
1032
1033   DEFVAR_INT ("emacs-priority", &emacs_priority,
1034     "Priority for Emacs to run at.\n\
1035 This value is effective only if set before Emacs is dumped,\n\
1036 and only if the Emacs executable is installed with setuid to permit\n\
1037 it to change priority.  (Emacs sets its uid back to the real uid.)");
1038   emacs_priority = 0;
1039
1040   staticpro (&Vinstallation_directory);
1041   Vinstallation_directory = Qnil;
1042
1043   /* These have already been set, in init_cmdargs, so don't set them here.  */
1044   staticpro (&Vinvocation_name);
1045   staticpro (&Vinvocation_directory);
1046 }