src/emacs.c

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