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