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 #ifdef MULTI_FRAME
 498       syms_of_frame ();
 499 #endif
 500       syms_of_syntax ();
 501       syms_of_undo ();
 502 #ifdef VMS
 503       syms_of_vmsproc ();
 504 #endif /* VMS */
 505       syms_of_window ();
 506       syms_of_xdisp ();
 507 #ifdef HAVE_X_WINDOWS
 508       syms_of_xterm ();
 509       syms_of_xfns ();
 510 #ifdef HAVE_X11
 511       syms_of_xselect ();
 512 #endif
 513 #ifdef HAVE_X_MENU
 514       syms_of_xmenu ();
 515 #endif /* HAVE_X_MENU */
 516 #endif /* HAVE_X_WINDOWS */
 517
 518 #ifdef SYMS_SYSTEM
 519       SYMS_SYSTEM;
 520 #endif
 521
 522 #ifdef SYMS_MACHINE
 523       SYMS_MACHINE;
 524 #endif
 525
 526       keys_of_casefiddle ();
 527       keys_of_cmds ();
 528       keys_of_buffer ();
 529       keys_of_keyboard ();
 530       keys_of_keymap ();
 531       keys_of_macros ();
 532       keys_of_minibuf ();
 533       keys_of_window ();
 534     }
 535
 536   if (!initialized)
 537     {
 538       /* Handle -l loadup-and-dump, args passed by Makefile. */
 539       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
 540         Vtop_level = Fcons (intern ("load"),
 541                             Fcons (build_string (argv[2 + skip_args]), Qnil));
 542 #ifdef CANNOT_DUMP
 543       /* Unless next switch is -nl, load "loadup.el" first thing.  */
 544       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
 545         Vtop_level = Fcons (intern ("load"),
 546                             Fcons (build_string ("loadup.el"), Qnil));
 547 #endif /* CANNOT_DUMP */
 548     }
 549
 550   initialized = 1;
 551
 552 #ifdef sun
 553   /* sun's localtime() has a bug.  it caches the value of the time
 554      zone rather than looking it up every time.  Since localtime() is
 555      called to bolt the undumping time into the undumped emacs, this
 556      results in localtime() ignoring the TZ environment variable.
 557      This flushes the new TZ value into localtime(). */
 558   tzset();
 559 #endif /* sun */
 560
 561   /* Enter editor command loop.  This never returns.  */
 562   Frecursive_edit ();
 563   /* NOTREACHED */
 564 }
 565 \f
 566 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
 567   "Exit the Emacs job and kill it.  Ask for confirmation, without argument.\n\
 568 If ARG is an integer, return ARG as the exit program code.\n\
 569 If ARG is a  string, stuff it as keyboard input.\n\n\
 570 The value of `kill-emacs-hook', if not void,\n\
 571 is a list of functions (of no args),\n\
 572 all of which are called before Emacs is actually killed.")
 573   (arg)
 574      Lisp_Object arg;
 575 {
 576   Lisp_Object hook, hook1;
 577   int i;
 578   struct gcpro gcpro1;
 579
 580   GCPRO1 (arg);
 581
 582   if (feof (stdin))
 583     arg = Qt;
 584
 585   if (!NILP (Vrun_hooks) && !noninteractive)
 586     call1 (Vrun_hooks, intern ("kill-emacs-hook"));
 587
 588   kill_buffer_processes (Qnil);
 589
 590 #ifdef VMS
 591   kill_vms_processes ();
 592 #endif /* VMS */
 593
 594   Fdo_auto_save (Qt, Qnil);
 595
 596 #ifdef CLASH_DETECTION
 597   unlock_all_files ();
 598 #endif /* CLASH_DETECTION */
 599
 600   fflush (stdout);
 601   reset_sys_modes ();
 602
 603 #ifdef HAVE_X_WINDOWS
 604   if (!noninteractive && EQ (Vwindow_system, intern ("x")))
 605     Fx_close_current_connection ();
 606 #endif /* HAVE_X_WINDOWS */
 607
 608   UNGCPRO;
 609
 610 /* Is it really necessary to do this deassign
 611    when we are going to exit anyway?  */
 612 /* #ifdef VMS
 613   stop_vms_input ();
 614  #endif  */
 615   stuff_buffered_input (arg);
 616 #ifdef SIGIO
 617   /* There is a tendency for a SIGIO signal to arrive within exit,
 618      and cause a SIGHUP because the input descriptor is already closed.  */
 619   unrequest_sigio ();
 620   signal (SIGIO, SIG_IGN);
 621 #endif
 622   exit ((XTYPE (arg) == Lisp_Int) ? XINT (arg)
 623 #ifdef VMS
 624         : 1
 625 #else
 626         : 0
 627 #endif
 628         );
 629   /* NOTREACHED */
 630 }
 631 \f
 632 #ifndef CANNOT_DUMP
 633 /* Nothing like this can be implemented on an Apollo.
 634    What a loss!  */
 635
 636 #ifdef HAVE_SHM
 637
 638 DEFUN ("dump-emacs-data", Fdump_emacs_data, Sdump_emacs_data, 1, 1, 0,
 639   "Dump current state of Emacs into data file FILENAME.\n\
 640 This function exists on systems that use HAVE_SHM.")
 641   (intoname)
 642      Lisp_Object intoname;
 643 {
 644   extern int my_edata;
 645   Lisp_Object tem;
 646   extern void malloc_warning ();
 647
 648   CHECK_STRING (intoname, 0);
 649   intoname = Fexpand_file_name (intoname, Qnil);
 650
 651   tem = Vpurify_flag;
 652   Vpurify_flag = Qnil;
 653
 654   fflush (stdout);
 655   /* Tell malloc where start of impure now is */
 656   /* Also arrange for warnings when nearly out of space.  */
 657 #ifndef SYSTEM_MALLOC
 658   malloc_init (&my_edata, malloc_warning);
 659 #endif
 660   map_out_data (XSTRING (intoname)->data);
 661
 662   Vpurify_flag = tem;
 663
 664   return Qnil;
 665 }
 666
 667 #else /* not HAVE_SHM */
 668
 669 DEFUN ("dump-emacs", Fdump_emacs, Sdump_emacs, 2, 2, 0,
 670   "Dump current state of Emacs into executable file FILENAME.\n\
 671 Take symbols from SYMFILE (presumably the file you executed to run Emacs).\n\
 672 This is used in the file `loadup.el' when building Emacs.\n\
 673 \n\
 674 Bind `command-line-processed' to nil before dumping,\n\
 675 if you want the dumped Emacs to process its command line\n\
 676 and announce itself normally when it is run.")
 677   (intoname, symname)
 678      Lisp_Object intoname, symname;
 679 {
 680   extern int my_edata;
 681   Lisp_Object tem;
 682   extern void malloc_warning ();
 683
 684   CHECK_STRING (intoname, 0);
 685   intoname = Fexpand_file_name (intoname, Qnil);
 686   if (!NILP (symname))
 687     {
 688       CHECK_STRING (symname, 0);
 689       if (XSTRING (symname)->size)
 690         symname = Fexpand_file_name (symname, Qnil);
 691     }
 692
 693   tem = Vpurify_flag;
 694   Vpurify_flag = Qnil;
 695
 696   fflush (stdout);
 697 #ifdef VMS
 698   mapout_data (XSTRING (intoname)->data);
 699 #else
 700   /* Tell malloc where start of impure now is */
 701   /* Also arrange for warnings when nearly out of space.  */
 702 #ifndef SYSTEM_MALLOC
 703   malloc_init (&my_edata, malloc_warning);
 704 #endif
 705   unexec (XSTRING (intoname)->data,
 706           !NILP (symname) ? XSTRING (symname)->data : 0, &my_edata, 0, 0);
 707 #endif /* not VMS */
 708
 709   Vpurify_flag = tem;
 710
 711   return Qnil;
 712 }
 713
 714 #endif /* not HAVE_SHM */
 715
 716 #endif /* not CANNOT_DUMP */
 717 \f
 718 #ifdef VMS
 719 #define SEPCHAR ','
 720 #else
 721 #define SEPCHAR ':'
 722 #endif
 723
 724 Lisp_Object
 725 decode_env_path (evarname, defalt)
 726      char *evarname, *defalt;
 727 {
 728   register char *path, *p;
 729   extern char *index ();
 730
 731   Lisp_Object lpath;
 732
 733   /* It's okay to use getenv here, because this function is only used
 734      to initialize variables when Emacs starts up, and isn't called
 735      after that.  */
 736   if (evarname != 0)
 737     path = (char *) getenv (evarname);
 738   else
 739     path = 0;
 740   if (!path)
 741     path = defalt;
 742   lpath = Qnil;
 743   while (1)
 744     {
 745       p = index (path, SEPCHAR);
 746       if (!p) p = path + strlen (path);
 747       lpath = Fcons (p - path ? make_string (path, p - path) : Qnil,
 748                      lpath);
 749       if (*p)
 750         path = p + 1;
 751       else
 752         break;
 753     }
 754   return Fnreverse (lpath);
 755 }
 756
 757 syms_of_emacs ()
 758 {
 759 #ifdef HAVE_SHM
 760   defsubr (&Sdump_emacs_data);
 761 #else
 762   defsubr (&Sdump_emacs);
 763 #endif
 764
 765   defsubr (&Skill_emacs);
 766
 767   DEFVAR_LISP ("command-line-args", &Vcommand_line_args,
 768     "Args passed by shell to Emacs, as a list of strings.");
 769
 770   DEFVAR_LISP ("system-type", &Vsystem_type,
 771     "Value is symbol indicating type of operating system you are using.");
 772   Vsystem_type = intern (SYSTEM_TYPE);
 773
 774   DEFVAR_BOOL ("noninteractive", &noninteractive1,
 775     "Non-nil means Emacs is running without interactive terminal.");
 776
 777   Vkill_emacs_hook = Qnil;
 778
 779   DEFVAR_LISP ("kill-emacs-hook", &Vkill_emacs_hook,
 780     "Hook to be run whenever kill-emacs is called.");
 781 }