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