src/emacs.c

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