src/emacs.c

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