284
|
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
|
505
|
42 #ifdef HAVE_TERMIOS
|
|
43 #include <termios.h>
|
|
44 #endif
|
|
45
|
284
|
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
|
|
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. */
|
505
|
113 SIGTYPE
|
284
|
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 */
|
505
|
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 */
|
284
|
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
|
|
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
|
|
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
|
348
|
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. */
|
284
|
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
|
420
|
302 /* Handle the -t switch, which specifies filename to use as terminal */
|
284
|
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
|
348 #ifdef POSIX_SIGNALS
|
|
349 init_signals ();
|
|
350 #endif
|
|
351
|
284
|
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);
|
372
|
390 #ifdef SIGIO
|
284
|
391 signal (SIGAIO, fatal_error_signal);
|
|
392 signal (SIGPTY, fatal_error_signal);
|
372
|
393 #endif
|
284
|
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 ();
|
348
|
423 init_lread ();
|
284
|
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 ();
|
348
|
462 syms_of_lread ();
|
284
|
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
|
375
|
511 syms_of_xterm ();
|
284
|
512 syms_of_xfns ();
|
375
|
513 #ifdef HAVE_X11
|
|
514 syms_of_xselect ();
|
|
515 #endif
|
284
|
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
|
|
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
|
505
|
579 if (!NILP (Vrun_hooks) && !noninteractive)
|
284
|
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
|
|
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);
|
505
|
682 if (!NILP (symname))
|
284
|
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,
|
505
|
702 !NILP (symname) ? XSTRING (symname)->data : 0, &my_edata, 0, 0);
|
284
|
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
|
|
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
|
505
|
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);
|
284
|
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 }
|