1 /* XEmacs -- Fully extensible Emacs, running on Unix and other platforms.
2 Copyright (C) 1985, 1986, 1987, 1992, 1993, 1994
3 Free Software Foundation, Inc.
4 Copyright (C) 1995 Sun Microsystems, Inc.
5 Copyright (C) 2000 Ben Wing.
7 This file is part of XEmacs.
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING. If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* Synched up with: Mule 2.0, FSF 19.28. */
26 /* Capsule summary of the various releases of Lucid Emacs/XEmacs and
27 FSF/GNU Emacs. Provided here for use in cross-referencing version
28 releases and dates in comments, esp. in the authorship comments at
29 the beginning of each file. More information about history can be
30 found in the beginning of the Internals Manual and in the About page.
33 -- A time line for Lucid Emacs/XEmacs is
35 version 19.0 shipped with Energize 1.0, April 1992.
36 version 19.1 released June 4, 1992.
37 version 19.2 released June 19, 1992.
38 version 19.3 released September 9, 1992.
39 version 19.4 released January 21, 1993.
40 version 19.5 was a repackaging of 19.4 with a few bug fixes and
41 shipped with Energize 2.0. Never released to the net.
42 version 19.6 released April 9, 1993.
43 version 19.7 was a repackaging of 19.6 with a few bug fixes and
44 shipped with Energize 2.1. Never released to the net.
45 version 19.8 released September 6, 1993.
46 version 19.9 released January 12, 1994.
47 version 19.10 released May 27, 1994.
48 version 19.11 (first XEmacs) released September 13, 1994.
49 version 19.12 released June 23, 1995.
50 version 19.13 released September 1, 1995.
51 version 19.14 released June 23, 1996.
52 version 20.0 released February 9, 1997.
53 version 19.15 released March 28, 1997.
54 version 20.1 (not released to the net) April 15, 1997.
55 version 20.2 released May 16, 1997.
56 version 19.16 released October 31, 1997.
57 version 20.3 (the first stable version of XEmacs 20.x) released
59 version 20.4 released February 28, 1998.
62 -- A time line for GNU Emacs version 19 is
64 version 19.7 (beta) (first beta release) released ??????; prob. late May 1993.
65 version 19.8 (beta) released May 27, 1993.
66 version 19.9 (beta) released May 27, 1993.
67 version 19.10 (beta) released May 30, 1993.
68 version 19.11 (beta) released June 1, 1993.
69 version 19.12 (beta) released June 2, 1993.
70 version 19.13 (beta) released June 8, 1993.
71 version 19.14 (beta) released June 17, 1993.
72 version 19.15 (beta) released June 19, 1993.
73 version 19.16 (beta) released July 6, 1993.
74 version 19.17 (beta) released late July, 1993.
75 version 19.18 (beta) released August 9, 1993.
76 version 19.19 (beta) released August 15, 1993.
77 version 19.20 (beta) released November 17, 1993.
78 version 19.21 (beta) released November 17, 1993.
79 version 19.22 (beta) released November 28, 1993.
80 version 19.23 (beta) released May 17, 1994.
81 version 19.24 (beta) released May 16, 1994.
82 version 19.25 (beta) released June 3, 1994.
83 version 19.26 (beta) released September 11, 1994.
84 version 19.27 (beta) released September 14, 1994.
85 version 19.28 (first ``official'' release) released November 1, 1994.
86 version 19.29 released June 21, 1995.
87 version 19.30 released November 24, 1995.
88 version 19.31 released May 25, 1996.
89 version 19.32 released July 31, 1996.
90 version 19.33 released August 11, 1996.
91 version 19.34 released August 21, 1996.
92 version 19.34b released September 6, 1996.
95 -- A time line for GNU Emacs version 20 is
97 version 20.1 released September 17, 1997.
98 version 20.2 released September 20, 1997.
99 version 20.3 released August 19, 1998.
102 -- A time line for GNU Emacs version 18 and older is
104 GNU Emacs version 15 (15.34) was released sometime in 1984 or 1985 and
105 shared some code with a version of Emacs written by James Gosling (the
106 same James Gosling who later created the Java language).
107 GNU Emacs version 16 (first released version was 16.56) was released on
108 July 15, 1985. All Gosling code was removed due to potential copyright
109 problems with the code.
110 version 16.57: released on September 16, 1985.
111 versions 16.58, 16.59: released on September 17, 1985.
112 version 16.60: released on September 19, 1985. These later version 16's
113 incorporated patches from the net, esp. for getting Emacs to work under
115 version 17.36 (first official v17 release) released on December 20, 1985.
116 Included a TeX-able user manual. First official unpatched version that
117 worked on vanilla System V machines.
118 version 17.43 (second official v17 release) released on January 25, 1986.
119 version 17.45 released on January 30, 1986.
120 version 17.46 released on February 4, 1986.
121 version 17.48 released on February 10, 1986.
122 version 17.49 released on February 12, 1986.
123 version 17.55 released on March 18, 1986.
124 version 17.57 released on March 27, 1986.
125 version 17.58 released on April 4, 1986.
126 version 17.61 released on April 12, 1986.
127 version 17.63 released on May 7, 1986.
128 version 17.64 released on May 12, 1986.
129 version 18.24 (a beta version) released on October 2, 1986.
130 version 18.30 (a beta version) released on November 15, 1986.
131 version 18.31 (a beta version) released on November 23, 1986.
132 version 18.32 (a beta version) released on December 7, 1986.
133 version 18.33 (a beta version) released on December 12, 1986.
134 version 18.35 (a beta version) released on January 5, 1987.
135 version 18.36 (a beta version) released on January 21, 1987.
136 January 27, 1987: The Great Usenet Renaming. net.emacs is now comp.emacs.
137 version 18.37 (a beta version) released on February 12, 1987.
138 version 18.38 (a beta version) released on March 3, 1987.
139 version 18.39 (a beta version) released on March 14, 1987.
140 version 18.40 (a beta version) released on March 18, 1987.
141 version 18.41 (the first ``official'' release) released on March 22, 1987.
142 version 18.45 released on June 2, 1987.
143 version 18.46 released on June 9, 1987.
144 version 18.47 released on June 18, 1987.
145 version 18.48 released on September 3, 1987.
146 version 18.49 released on September 18, 1987.
147 version 18.50 released on February 13, 1988.
148 version 18.51 released on May 7, 1988.
149 version 18.52 released on September 1, 1988.
150 version 18.53 released on February 24, 1989.
151 version 18.54 released on April 26, 1989.
152 version 18.55 released on August 23, 1989. This is the earliest version
153 that is still available by FTP.
154 version 18.56 released on January 17, 1991.
155 version 18.57 released late January, 1991.
156 version 18.58 released ?????.
157 version 18.59 released October 31, 1992.
161 /* Note: It is necessary to specify <config.h> and not "config.h" in
162 order for the --srcdir type of compilation to work properly.
163 Otherwise the config.h from the srcdir, rather than the one from
164 the build dir, will be used. */
169 #include "backtrace.h" /* run-emacs-from-temacs needs this */
171 #include "commands.h"
174 #include "redisplay.h"
178 #include "syssignal.h" /* Always include before systty.h */
193 #include <quantify.h>
200 #if defined (HAVE_LOCALE_H) && \
201 (defined (I18N2) || defined (I18N3) || defined (I18N4))
209 #if defined (WIN32_NATIVE)
216 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
217 void report_sheap_usage (int die_if_pure_storage_exceeded);
220 #if !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC)
221 extern void *(*__malloc_hook)(size_t);
222 extern void *(*__realloc_hook)(void *, size_t);
223 extern void (*__free_hook)(void *);
224 #endif /* not SYSTEM_MALLOC && not DOUG_LEA_MALLOC */
226 /* Command line args from shell, as list of strings */
227 Lisp_Object Vcommand_line_args;
229 /* Set nonzero after XEmacs has started up the first time.
230 Prevents reinitialization of the Lisp world and keymaps
231 on subsequent starts. */
234 #ifdef DOUG_LEA_MALLOC
236 /* Preserves a pointer to the memory allocated that copies that
237 static data inside glibc's malloc. */
238 static void *malloc_state_ptr;
239 #endif /* DOUG_LEA_MALLOC */
242 void r_alloc_reinit (void);
245 /* Variable whose value is symbol giving operating system type. */
246 Lisp_Object Vsystem_type;
248 /* Variable whose value is string giving configuration built for. */
249 Lisp_Object Vsystem_configuration;
251 /* Variable whose value is string containing the configuration options
252 XEmacs was built with. */
253 Lisp_Object Vsystem_configuration_options;
255 /* Version numbers and strings */
256 Lisp_Object Vemacs_major_version;
257 Lisp_Object Vemacs_minor_version;
258 Lisp_Object Vemacs_patch_level;
259 Lisp_Object Vemacs_beta_version;
260 Lisp_Object Vxemacs_codename;
262 Lisp_Object Vinfodock_major_version;
263 Lisp_Object Vinfodock_minor_version;
264 Lisp_Object Vinfodock_build_version;
267 /* The path under which XEmacs was invoked. */
268 Lisp_Object Vinvocation_path;
270 /* The name under which XEmacs was invoked, with any leading directory
272 Lisp_Object Vinvocation_name;
274 /* The directory name from which XEmacs was invoked. */
275 Lisp_Object Vinvocation_directory;
278 /* The directory name in which to find subdirs such as lisp and etc.
279 nil means get them only from PATH_LOADSEARCH. */
280 Lisp_Object Vinstallation_directory;
283 Lisp_Object Vemacs_program_name, Vemacs_program_version;
284 Lisp_Object Vexec_path;
285 Lisp_Object Vexec_directory, Vconfigure_exec_directory;
286 Lisp_Object Vlisp_directory, Vconfigure_lisp_directory;
287 Lisp_Object Vmodule_directory, Vconfigure_module_directory;
288 Lisp_Object Vsite_module_directory, Vconfigure_site_module_directory;
289 Lisp_Object Vconfigure_package_path;
290 Lisp_Object Vdata_directory, Vconfigure_data_directory;
291 Lisp_Object Vdoc_directory, Vconfigure_doc_directory;
292 Lisp_Object Vconfigure_lock_directory;
293 Lisp_Object Vdata_directory_list;
294 Lisp_Object Vconfigure_info_directory;
295 Lisp_Object Vsite_directory, Vconfigure_site_directory;
296 Lisp_Object Vconfigure_info_path;
297 Lisp_Object Vinternal_error_checking;
298 Lisp_Object Vmail_lock_methods, Vconfigure_mail_lock_method;
299 Lisp_Object Vpath_separator;
301 /* The default base directory XEmacs is installed under. */
302 Lisp_Object Vconfigure_exec_prefix_directory, Vconfigure_prefix_directory;
304 /* If nonzero, set XEmacs to run at this priority. This is also used
305 in child_setup and sys_suspend to make sure subshells run at normal
309 /* Some FSF junk with running_asynch_code, to preserve the match
310 data. Not necessary because we don't call process filters
311 asynchronously (i.e. from within QUIT). */
312 /* #### Delete this when merging the rest of my code */
313 int running_asynch_code;
315 /* If non-zero, a window-system was specified on the command line. */
318 /* Type of display specified. We cannot use a Lisp symbol here because
319 Lisp symbols may not initialized at the time that we set this
321 const char *display_use;
323 /* If non-zero, then the early error handler will only print the error
325 int suppress_early_error_handler_backtrace;
327 /* An address near the bottom of the stack.
328 Tells GC how to save a copy of the stack. */
331 #ifdef USG_SHARED_LIBRARIES
332 /* If nonzero, this is the place to put the end of the writable segment
335 uintptr_t bss_end = 0;
338 /* Number of bytes of writable memory we can expect to be able to get */
339 unsigned int lim_data;
343 Some LISP-visible command-line options are set by XEmacs _before_ the
344 data is dumped in building a --pdump XEmacs, but used _after_ it is
345 restored in normal operation. Thus the restored values overwrite the
346 values XEmacs is getting at run-time. Such variables must be saved
347 before loading the dumpfile, and restored afterward.
349 This is done immediately before and after pdump_load() in main_1().
350 See that function for the current list of protected variables.
352 Note that if the variable is never DEFVAR'd, saving/restoring is not
356 /* Nonzero means running XEmacs without interactive terminal. */
360 /* Value of Lisp variable `noninteractive'.
361 Normally same as C variable `noninteractive'
362 but nothing terrible happens if user sets this one.
364 Shadowed from the pdumper by `noninteractive'. */
368 /* Nonzero means don't perform site-lisp searches at startup */
369 int inhibit_site_lisp;
371 /* Nonzero means don't perform site-modules searches at startup */
372 int inhibit_site_modules;
374 /* Nonzero means don't respect early packages at startup */
375 int inhibit_early_packages;
377 /* Nonzero means don't load package autoloads at startup */
378 int inhibit_autoloads;
380 /* Nonzero means don't load the dump file (ignored if not PDUMP) */
384 /* Nonzero means print debug information about path searching */
387 /* Save argv and argc. */
388 static Extbyte **initial_argv;
389 static int initial_argc;
391 static void sort_args (int argc, char **argv);
393 Lisp_Object Qkill_emacs_hook;
394 Lisp_Object Qsave_buffers_kill_emacs;
396 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
400 /* Ben's capsule summary about expected and unexpected exits from XEmacs.
402 Expected exits occur when the user directs XEmacs to exit, for example
403 by pressing the close button on the only frame in XEmacs, or by typing
404 C-x C-c. This runs `save-buffers-kill-emacs', which saves any necessary
405 buffers, and then exits using the primitive `kill-emacs'.
407 However, unexpected exits occur in a few different ways:
409 -- a memory access violation or other hardware-generated exception
410 occurs. This is the worst possible problem to deal with, because
411 the fault can occur while XEmacs is in any state whatsoever, even
412 quite unstable ones. As a result, we need to be *extremely* careful
414 -- we are using one X display (or if we've used more, we've closed the
415 others already), and some hardware or other problem happens and
416 suddenly we've lost our connection to the display. In this situation,
417 things are not so dire as in the last one; our code itself isn't
418 trashed, so we can continue execution as normal, after having set
419 things up so that we can exit at the appropriate time. Our exit
420 still needs to be of the emergency nature; we have no displays, so
421 any attempts to use them will fail. We simply want to auto-save
422 (the single most important thing to do during shut-down), do minimal
423 cleanup of stuff that has an independent existence outside of XEmacs,
426 Currently, both unexpected exit scenarios described above set
427 preparing_for_armageddon to indicate that nonessential and possibly
428 dangerous things should not be done, specifically:
430 -- no garbage collection.
432 -- no messages of any sort from autosaving.
433 -- autosaving tries harder, ignoring certain failures.
434 -- existing frames are not deleted.
436 (Also, all places that set preparing_for_armageddon also
437 set dont_check_for_quit. This happens separately because it's
438 also necessary to set other variables to make absolutely sure
439 no quitting happens.)
441 In the first scenario above (the access violation), we also set
442 fatal_error_in_progress. This causes more things to not happen:
444 -- assertion failures do not abort.
445 -- printing code does not do code conversion or gettext when
446 printing to stdout/stderr.
449 /* Nonzero if handling a fatal error already. */
450 int fatal_error_in_progress;
452 /* Non-nil means we're going down, so we better not run any hooks
453 or do other non-essential stuff. */
454 int preparing_for_armageddon;
457 static JMP_BUF run_temacs_catch;
459 static int run_temacs_argc;
460 static char **run_temacs_argv;
461 static char *run_temacs_args;
462 static size_t run_temacs_argv_size;
463 static size_t run_temacs_args_size;
465 static void shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save);
468 ensure_no_quitting_from_now_on (void)
470 /* make sure no quitting from now on!! */
471 dont_check_for_quit = 1;
476 /* Handle bus errors, illegal instruction, etc. */
478 fatal_error_signal (int sig)
480 fatal_error_in_progress++;
481 preparing_for_armageddon = 1;
483 ensure_no_quitting_from_now_on ();
485 /* Unblock the signal so that if the same signal gets sent in the
486 code below, we avoid a deadlock. */
487 EMACS_UNBLOCK_SIGNAL (sig);
489 /* Only try auto-saving first time through. If we crash in auto-saving,
490 don't do it again. */
491 if (fatal_error_in_progress == 1)
493 Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
494 /* Do this so that the variable has the same value of 2 regardless of
495 whether we made it through auto-saving correctly. */
496 fatal_error_in_progress++;
498 else if (fatal_error_in_progress == 2)
499 stderr_out ("WARNING: Unable to auto-save your files properly.\n"
500 "Some or all may in fact have been auto-saved.\n"
503 /* Now, reset our signal handler, so the next time, we just die.
504 Don't do this before auto-saving. */
505 signal (sig, SIG_DFL);
507 /* Keep in mind that there's more than one signal that we can crash
509 /* If fatal error occurs in code below, avoid infinite recursion. */
510 if (fatal_error_in_progress <= 2)
512 shut_down_emacs (sig, Qnil, 1);
513 stderr_out ("\nLisp backtrace follows:\n\n");
514 Fbacktrace (Qexternal_debugging_output, Qt);
515 # if 0 /* This is evil, rarely useful, and causes grief in some cases. */
516 /* Check for Sun-style stack printing via /proc */
518 const char *pstack = "/usr/proc/bin/pstack";
519 if (access (pstack, X_OK) == 0)
522 stderr_out ("\nC backtrace follows:\n"
523 "(A real debugger may provide better information)\n\n");
524 sprintf (buf, "%s %d >&2", pstack, (int)getpid());
530 /* Signal the same code; this time it will really be fatal. */
531 kill (getpid (), sig);
538 mswindows_handle_hardware_exceptions (DWORD code)
540 if (code != STATUS_ACCESS_VIOLATION && code != STATUS_ILLEGAL_INSTRUCTION
541 && code != STATUS_PRIVILEGED_INSTRUCTION
542 && code != STATUS_DATATYPE_MISALIGNMENT)
543 return EXCEPTION_CONTINUE_SEARCH;
545 /* I don't know if this filter is still wrapped in the outer __try, but
546 it doesn't hurt to have another one. --ben
547 And it lets us control more exactly what we really want to do in such
551 fatal_error_in_progress++;
552 preparing_for_armageddon = 1;
554 ensure_no_quitting_from_now_on ();
556 /* Only try auto-saving first time through. If we crash in auto-saving,
557 don't do it again. */
558 if (fatal_error_in_progress == 1)
560 Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
561 /* Do this so that the variable has the same value of 2 regardless of
562 whether we made it through auto-saving correctly. */
563 fatal_error_in_progress++;
565 else if (fatal_error_in_progress == 2)
566 stderr_out ("WARNING: Unable to auto-save your files properly.\n"
567 "Some or all may in fact have been auto-saved.\n"
570 /* If fatal error occurs in code below, avoid infinite recursion. */
571 if (fatal_error_in_progress <= 2)
573 shut_down_emacs (-1, Qnil, 1);
574 stderr_out ("\nLisp backtrace follows:\n\n");
575 Fbacktrace (Qexternal_debugging_output, Qt);
578 /* VC++ documentation says that
579 GetExceptionCode() cannot be called inside the filter itself. */
581 /* __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {}
583 The line above is original. Unfortunately, when an error is tripped
584 inside of the handler (e.g. during Fbacktrace()), and the handler for
585 the handler is invoked, it correctly notices that something is amiss
586 and it should just return -- but it returns EXCEPTION_CONTINUE_SEARCH,
587 which causes the debugger to be invoked debugging the handler code in
588 this function -- and WITH THE STACK UNWOUND so that you see main()
589 calling mswindows_handle_hardware_exceptions(), calling Fbacktrace(),
590 and a crash a couple of frames in -- AND NO SIGN OF THE ORIGINAL CRASH!
592 There's some real weirdness going on in the stack handling -- unlike
593 in Unix, where further crashes just keep adding to the stack, it seems
594 that under the structured-exception-handling, the stack can actually
595 bounce back and forth between the full stack at the location of the
596 exception and the unwound stack at the place where the __try clause was
597 established. I don't completely understand it. What I do know is that
598 returning EXCEPTION_EXECUTE_HANDLER on nested crash has the effect of
599 aborting execution of the handler and going back to the outer filter
600 function, which returns EXCEPTION_CONTINUE_SEARCH and everything is
601 hunky-dorey -- your debugger sees a crash at the right location with
604 I'm leaving in the trickier Unix-like code in the handler; someone who
605 understands better than me how the stack works in these handlers could
606 fix it up more. As it is, it works pretty well, so I'm not likely to
610 __except (EXCEPTION_EXECUTE_HANDLER) {}
613 /* pretend we didn't handle this, so that the debugger is invoked and/or
614 the normal GPF box appears. */
615 return EXCEPTION_CONTINUE_SEARCH;
618 #endif /* _MSC_VER */
624 /* Handler for SIGDANGER. */
626 memory_warning_signal (int sig)
628 /* #### bad bad bad; this function shouldn't do anything except
629 set a flag, or weird corruption could happen. */
630 signal (sig, memory_warning_signal);
633 (GETTEXT ("Operating system warns that virtual memory is running low.\n"));
635 /* It might be unsafe to call do_auto_save now. */
636 force_auto_save_soon ();
638 #endif /* SIGDANGER */
640 /* Code for dealing with Lisp access to the Unix command line */
643 make_arg_list_1 (int argc, Extbyte **argv, int skip_args)
645 Lisp_Object result = Qnil;
648 for (i = argc - 1; i >= 0; i--)
650 if (i == 0 || i > skip_args)
655 /* Do not trust to what crt0 has stuffed into argv[0] */
656 char full_exe_path[MAX_PATH];
657 Lisp_Object fullpath;
659 GetModuleFileName (NULL, full_exe_path, MAX_PATH);
660 fullpath = build_ext_string (full_exe_path, Qmswindows_tstr);
661 result = Fcons (fullpath, result);
662 #if defined(HAVE_SHLIB)
664 Extbyte *fullpathext;
666 LISP_STRING_TO_EXTERNAL (fullpath, fullpathext,
667 Qdll_filename_encoding);
668 (void) dll_init (fullpathext);
674 result = Fcons (build_ext_string (argv[i],
675 Qcommand_argument_encoding),
683 make_arg_list (int argc, Extbyte **argv)
685 return make_arg_list_1 (argc, argv, 0);
688 /* Calling functions are also responsible for calling free_argc_argv
689 when they are done with the generated list. */
691 make_argc_argv (Lisp_Object argv_list, int *argc, Extbyte ***argv)
694 int n = XINT (Flength (argv_list));
696 *argv = (Extbyte**) xmalloc ((n+1) * sizeof (Extbyte*));
698 for (i = 0, next = argv_list; i < n; i++, next = XCDR (next))
701 CHECK_STRING (XCAR (next));
703 LISP_STRING_TO_EXTERNAL (XCAR (next), temp, Qcommand_argument_encoding);
704 (*argv) [i] = xstrdup (temp);
711 free_argc_argv (Extbyte **argv)
724 init_cmdargs (int argc, Extbyte **argv, int skip_args)
729 Vcommand_line_args = make_arg_list_1 (argc, argv, skip_args);
732 DEFUN ("invocation-name", Finvocation_name, 0, 0, 0, /*
733 Return the program name that was used to run XEmacs.
734 Any directory names are omitted.
738 return Fcopy_sequence (Vinvocation_name);
741 DEFUN ("invocation-directory", Finvocation_directory, 0, 0, 0, /*
742 Return the directory name in which the Emacs executable was located.
746 return Fcopy_sequence (Vinvocation_directory);
751 /* #### - don't know why I18N4 on SunOS/JLE
752 can't deal with this. It's a potential
753 bug that needs to be looked at. */
754 # undef RUN_TIME_REMAP
757 /* Test whether the next argument in ARGV matches SSTR or a prefix of
758 LSTR (at least MINLEN characters). If so, then if VALPTR is non-null
759 (the argument is supposed to have a value) store in *VALPTR either
760 the next argument or the portion of this one after the equal sign.
761 ARGV is read starting at position *SKIPPTR; this index is advanced
762 by the number of arguments used.
764 Too bad we can't just use getopt for all of this, but we don't have
765 enough information to do it right. */
768 argmatch (char **argv, int argc, char *sstr, char *lstr,
769 int minlen, char **valptr, int *skipptr)
775 /* Don't access argv[argc]; give up in advance. */
776 if (argc <= *skipptr + 1)
779 arg = argv[*skipptr+1];
782 if (strcmp (arg, sstr) == 0)
786 *valptr = argv[*skipptr+2];
793 arglen = (valptr != NULL && (p = strchr (arg, '=')) != NULL
794 ? p - arg : strlen (arg));
795 if (lstr == 0 || arglen < minlen || strncmp (arg, lstr, arglen) != 0)
797 else if (valptr == NULL)
808 else if (argv[*skipptr+2] != NULL)
810 *valptr = argv[*skipptr+2];
820 /* Make stack traces always identify version + configuration */
821 #define main_1 STACK_TRACE_EYE_CATCHER
823 /* This function is not static, so that the compiler is less likely to
824 inline it, which would make it not show up in stack traces. */
825 DECLARE_DOESNT_RETURN (main_1 (int, char **, char **, int));
827 main_1 (int argc, char **argv, char **envp, int restart)
829 char stack_bottom_variable;
832 int inhibit_window_system;
834 extern int malloc_cookie;
837 #if (!defined (SYSTEM_MALLOC) && !defined (HAVE_LIBMCHECK) \
838 && !defined (DOUG_LEA_MALLOC))
839 /* Make sure that any libraries we link against haven't installed a
840 hook for a gmalloc of a potentially incompatible version. */
841 /* If we're using libmcheck, the hooks have already been initialized, */
842 /* don't touch them. -slb */
843 __malloc_hook = NULL;
844 __realloc_hook = NULL;
846 #endif /* not SYSTEM_MALLOC or HAVE_LIBMCHECK or DOUG_LEA_MALLOC */
852 * NeXT secret magic, ripped from Emacs-for-NS by Carl Edman
853 * <cedman@princeton.edu>. Note that even Carl doesn't know what this
854 * does; it was provided by NeXT, and it presumable makes NS's mallocator
855 * work with dumping. But malloc_jumpstart() and malloc_freezedry() in
856 * unexnext.c are both completely undocumented, even in NS header files!
857 * But hey, it solves all NS related memory problems, so who's
859 if (initialized && malloc_jumpstart (malloc_cookie) != 0)
860 stderr_out ("malloc jumpstart failed!\n");
864 #if defined (GNU_MALLOC) && \
865 defined (ERROR_CHECK_MALLOC) && \
866 !defined (HAVE_LIBMCHECK)
868 #if defined(LOSING_GCC_DESTRUCTOR_FREE_BUG)
869 /* Prior to XEmacs 21, this was `#if 0'ed out. */
870 /* I'm enabling this because it is the only reliable way I've found to */
871 /* prevent a very annoying problem where GCC will attempt to free(3) */
872 /* memory at exit() and cause a coredump. */
876 sort_args (argc, argv);
878 #if defined (WIN32_NATIVE) || defined (_SCO_DS)
882 /* Record (approximately) where the stack begins. */
883 stack_bottom = &stack_bottom_variable;
885 #ifdef USG_SHARED_LIBRARIES
887 brk ((void *) bss_end);
892 #if defined (HAVE_MMAP) && defined (REL_ALLOC)
893 /* ralloc can only be used if using the GNU memory allocator. */
895 #elif defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
903 #endif /* HAVE_SOCKS */
905 #ifndef SYSTEM_MALLOC
907 /* Arrange to get warning messages as memory fills up. */
908 memory_warnings (0, malloc_warning);
909 #endif /* not SYSTEM_MALLOC */
911 #ifdef SET_EMACS_PRIORITY
912 if (emacs_priority != 0)
913 nice (-emacs_priority);
915 #endif /* SET_EMACS_PRIORITY */
917 #ifdef EXTRA_INITIALIZE
921 #ifdef HAVE_WINDOW_SYSTEM
922 inhibit_window_system = 0;
924 inhibit_window_system = 1;
927 /* Handle the -sd/--show-dump-id switch, which means show the hex dump_id and quit */
928 if (argmatch (argv, argc, "-sd", "--show-dump-id", 9, NULL, &skip_args))
931 printf ("%08x\n", dump_id);
933 printf ("*ERROR**\n");
938 /* Handle the -t switch, which specifies filename to use as terminal */
941 if (argmatch (argv, argc, "-t", "--terminal", 4, &term, &skip_args))
945 if (open (term, O_RDWR | OPEN_BINARY, 2) < 0)
946 fatal ("%s: %s", term, strerror (errno));
949 fatal ("%s: not a tty", term);
952 stderr_out ("Using %s", ttyname (0));
954 stderr_out ("Using %s", term);
955 inhibit_window_system = 1; /* -t => -nw */
959 /* Handle the --no-dump-file/-nd switch, which means don't load the dump file (ignored when not using pdump) */
960 if (argmatch (argv, argc, "-nd", "--no-dump-file", 7, NULL, &skip_args))
965 /* Handle -nw switch */
966 if (argmatch (argv, argc, "-nw", "--no-windows", 6, NULL, &skip_args))
967 inhibit_window_system = 1;
969 /* Handle the -batch switch, which means don't do interactive display. */
970 if (argmatch (argv, argc, "-batch", "--batch", 5, NULL, &skip_args))
972 #if 0 /* I don't think this is correct. */
973 inhibit_autoloads = 1;
978 if (argmatch (argv, argc, "-debug-paths", "--debug-paths",
979 11, NULL, &skip_args))
982 /* Partially handle -no-autoloads, -no-early-packages and -vanilla. Packages */
983 /* are searched prior to the rest of the command line being parsed in */
985 if (argmatch (argv, argc, "-no-early-packages", "--no-early-packages",
986 6, NULL, &skip_args))
988 inhibit_early_packages = 1;
992 if (argmatch (argv, argc, "-no-site-modules", "--no-site-modules",
993 9, NULL, &skip_args))
995 inhibit_site_modules = 1;
999 inhibit_site_modules = 1;
1001 if (argmatch (argv, argc, "-vanilla", "--vanilla",
1002 7, NULL, &skip_args))
1004 inhibit_early_packages = 1;
1008 if (argmatch (argv, argc, "-no-autoloads", "--no-autoloads",
1009 7, NULL, &skip_args))
1011 /* Inhibit everything */
1012 inhibit_autoloads = 1;
1016 if (argmatch (argv, argc, "-debug-paths", "--debug-paths",
1017 6, NULL, &skip_args))
1024 /* Partially handle the -version and -help switches: they imply -batch,
1025 but are not removed from the list. */
1026 if (argmatch (argv, argc, "-help", "--help", 3, NULL, &skip_args))
1027 noninteractive = 1, skip_args--;
1029 if (argmatch (argv, argc, "-version", "--version", 3, NULL, &skip_args) ||
1030 argmatch (argv, argc, "-V", 0, 2, NULL, &skip_args))
1031 noninteractive = 1, skip_args--;
1033 /* Now, figure out which type of console is our first console. */
1038 display_use = "stream";
1040 display_use = "tty";
1043 if (inhibit_window_system)
1044 fatal ("Sorry, this XEmacs was not compiled with TTY support");
1047 #ifdef HAVE_WINDOW_SYSTEM
1048 /* Stupid kludge to catch command-line display spec. We can't
1049 handle this argument entirely in window-system-dependent code
1050 because we don't even know which window-system-dependent code
1051 to run until we've recognized this argument. */
1052 if (!inhibit_window_system && !noninteractive)
1054 #ifdef HAVE_X_WINDOWS
1056 int count_before = skip_args;
1058 if (argmatch (argv, argc, "-d", "--display", 3, &dpy, &skip_args) ||
1059 argmatch (argv, argc, "-display", 0, 3, &dpy, &skip_args))
1064 /* If we have the form --display=NAME,
1065 convert it into -d name.
1066 This requires inserting a new element into argv. */
1067 if (dpy != 0 && skip_args - count_before == 1)
1069 char **new = (char **) xmalloc (sizeof (char *) * (argc + 2));
1072 for (j = 0; j < count_before + 1; j++)
1074 new[count_before + 1] = "-d";
1075 new[count_before + 2] = dpy;
1076 for (j = count_before + 2; j <argc; j++)
1077 new[j + 1] = argv[j];
1081 /* Change --display to -d, when its arg is separate. */
1082 else if (dpy != 0 && skip_args > count_before
1083 && argv[count_before + 1][1] == '-')
1084 argv[count_before + 1] = "-d";
1086 /* Don't actually discard this arg. */
1087 skip_args = count_before;
1089 /* If there is a non-empty environment var DISPLAY, set
1090 `display_use', but not `display_arg', which is only to be set
1091 if the display was specified on the command line. */
1092 if ((dpy = getenv ("DISPLAY")) && dpy[0])
1095 #endif /* HAVE_X_WINDOWS */
1096 #ifdef HAVE_MS_WINDOWS
1097 if (strcmp(display_use, "x") != 0)
1098 display_use = "mswindows";
1099 #endif /* HAVE_MS_WINDOWS */
1101 #endif /* HAVE_WINDOW_SYSTEM */
1103 noninteractive1 = noninteractive;
1105 /****** Now initialize everything *******/
1107 /* First, do really basic environment initialization -- catching signals
1108 and the like. These functions have no dependence on any part of
1109 the Lisp engine and need to be done both at dump time and at run time. */
1111 init_signals_very_early ();
1112 init_data_very_early (); /* Catch math errors. */
1113 #ifdef LISP_FLOAT_TYPE
1114 init_floatfns_very_early (); /* Catch floating-point math errors. */
1116 init_process_times_very_early (); /* Initialize our process timers.
1117 As early as possible, of course,
1118 so we can be fairly accurate. */
1119 init_intl_very_early (); /* set up the locale and domain for gettext and
1122 /* Now initialize the Lisp engine and the like. Done only during
1123 dumping. No dependence on anything that may be in the user's
1124 environment when the dumped XEmacs is run.
1126 We try to do things in an order that minimizes the non-obvious
1127 dependencies between functions. */
1129 /* purify_flag 1 is correct even if CANNOT_DUMP.
1130 * loadup.el will set to nil at end. */
1136 else if (nodumpfile) {
1141 /* Keep command options from getting stomped.
1143 Some LISP-visible options are changed by XEmacs _after_ the data is
1144 dumped in building a --pdump XEmacs, but _before_ it is restored in
1145 normal operation. Thus the restored values overwrite the values
1146 XEmacs is getting at run-time. Such variables must be saved here,
1147 and restored after loading the dumped data.
1149 Boy, this is ugly, but how else to do it?
1152 /* noninteractive1 is protected by noninteractive, which is not
1154 int inhibit_early_packages_save = inhibit_early_packages;
1155 int inhibit_autoloads_save = inhibit_autoloads;
1156 int debug_paths_save = debug_paths;
1157 #ifdef INHIBIT_SITE_LISP
1158 int inhibit_site_lisp_save = inhibit_site_lisp;
1160 #ifdef INHIBIT_SITE_MODULES
1161 int inhibit_site_modules_save = inhibit_site_modules;
1164 initialized = pdump_load (argv[0]);
1166 /* Now unstomp everything */
1167 noninteractive1 = noninteractive;
1168 inhibit_early_packages = inhibit_early_packages_save;
1169 inhibit_autoloads = inhibit_autoloads_save;
1170 debug_paths = debug_paths_save;
1171 #ifdef INHIBIT_SITE_LISP
1172 inhibit_site_lisp = inhibit_site_lisp_save;
1174 #ifdef INHIBIT_SITE_MODULES
1175 inhibit_site_modules = inhibit_site_modules_save;
1179 run_temacs_argc = -1;
1190 /* Initialize things so that new Lisp objects
1191 can be created and objects can be staticpro'd.
1192 Must be basically the very first thing done
1193 because pretty much all of the initialization
1194 routines below create new objects. */
1195 init_alloc_once_early ();
1197 /* Initialize Qnil, Qt, Qunbound, and the
1198 obarray. After this, symbols can be
1199 interned. This depends on init_alloc_once_early(). */
1200 init_symbols_once_early ();
1202 /* Declare the basic symbols pertaining to errors,
1203 So that DEFERROR*() can be called. */
1204 init_errors_once_early ();
1206 /* Make sure that opaque pointers can be created. */
1207 init_opaque_once_early ();
1209 /* Now declare all the symbols and define all the Lisp primitives.
1211 The *only* thing that the syms_of_*() functions are allowed to do
1212 is call one of the following:
1214 INIT_LRECORD_IMPLEMENTATION()
1215 defsymbol(), DEFSYMBOL(), or DEFSYMBOL_MULTIWORD_PREDICATE()
1216 defsubr() (i.e. DEFSUBR)
1217 deferror(), DEFERROR(), or DEFERROR_STANDARD()
1218 defkeyword() or DEFKEYWORD()
1220 Order does not matter in these functions.
1226 syms_of_bytecode ();
1228 syms_of_callproc ();
1229 syms_of_casefiddle ();
1239 #endif /* DEBUG_XEMACS */
1250 #ifdef HAVE_X_WINDOWS
1251 syms_of_event_Xt ();
1253 #ifdef HAVE_DRAGNDROP
1254 syms_of_dragdrop ();
1256 syms_of_event_stream ();
1261 #ifdef CLASH_DETECTION
1262 syms_of_filelock ();
1263 #endif /* CLASH_DETECTION */
1264 syms_of_floatfns ();
1266 syms_of_font_lock ();
1270 syms_of_glyphs_eimage ();
1271 syms_of_glyphs_widget ();
1281 #ifdef HAVE_DATABASE
1282 syms_of_database ();
1284 #ifdef HAVE_MENUBARS
1293 #if !defined (NO_SUBPROCESSES)
1295 #ifdef HAVE_WIN32_PROCESSES
1296 syms_of_process_nt ();
1300 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
1302 #endif /* HAVE_MMAP && REL_ALLOC */
1303 syms_of_rangetab ();
1304 syms_of_redisplay ();
1309 syms_of_specifier ();
1312 #ifdef HAVE_SCROLLBARS
1313 syms_of_scrollbar ();
1315 #ifdef HAVE_TOOLBARS
1323 syms_of_console_tty ();
1324 syms_of_device_tty ();
1325 syms_of_objects_tty ();
1328 #ifdef HAVE_X_WINDOWS
1329 #ifdef HAVE_BALLOON_HELP
1330 syms_of_balloon_x ();
1332 syms_of_device_x ();
1334 syms_of_dialog_x ();
1337 syms_of_glyphs_x ();
1338 syms_of_objects_x ();
1339 #ifdef HAVE_MENUBARS
1340 syms_of_menubar_x ();
1342 syms_of_select_x ();
1343 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
1348 syms_of_input_method_xlib ();
1350 #endif /* HAVE_XIM */
1351 #endif /* HAVE_X_WINDOWS */
1353 #ifdef HAVE_MS_WINDOWS
1354 syms_of_console_mswindows ();
1355 syms_of_device_mswindows ();
1356 syms_of_dialog_mswindows ();
1357 syms_of_frame_mswindows ();
1358 syms_of_objects_mswindows ();
1359 syms_of_select_mswindows ();
1360 syms_of_glyphs_mswindows ();
1361 syms_of_gui_mswindows ();
1362 #ifdef HAVE_MENUBARS
1363 syms_of_menubar_mswindows ();
1365 #ifdef HAVE_SCROLLBARS
1366 syms_of_scrollbar_mswindows ();
1368 #endif /* HAVE_MS_WINDOWS */
1369 #ifdef HAVE_MSW_C_DIRED
1370 syms_of_dired_mswindows ();
1375 #if defined (WIN32_NATIVE) || defined (CYGWIN)
1381 syms_of_mule_ccl ();
1382 syms_of_mule_charset ();
1385 syms_of_file_coding ();
1389 syms_of_mule_wnn ();
1392 syms_of_mule_canna ();
1393 #endif /* HAVE_CANNA */
1405 #if defined (GNU_MALLOC) && \
1406 defined (ERROR_CHECK_MALLOC) && \
1407 !defined (HAVE_LIBMCHECK)
1409 /* Prior to XEmacs 21, this was `#if 0'ed out. -slb */
1410 #if defined (LOSING_GCC_DESTRUCTOR_FREE_BUG)
1411 syms_of_free_hook ();
1415 syms_of_tooltalk ();
1427 syms_of_gpmevent ();
1430 #ifdef HAVE_POSTGRESQL
1431 syms_of_postgresql ();
1434 /* Now create the subtypes for the types that have them.
1435 We do this before the vars_*() because more symbols
1436 may get initialized here. */
1438 /* Now initialize the console types and associated symbols.
1439 Other than the first function below, the functions may
1440 make exactly the following function/macro calls:
1442 INITIALIZE_CONSOLE_TYPE()
1443 CONSOLE_HAS_METHOD()
1445 For any given console type, the former macro must be called
1446 before the any calls to the latter macro. */
1448 console_type_create ();
1450 console_type_create_stream ();
1453 console_type_create_tty ();
1454 console_type_create_device_tty ();
1455 console_type_create_frame_tty ();
1456 console_type_create_objects_tty ();
1457 console_type_create_redisplay_tty ();
1460 #ifdef HAVE_X_WINDOWS
1461 console_type_create_x ();
1462 console_type_create_device_x ();
1463 console_type_create_frame_x ();
1464 console_type_create_glyphs_x ();
1465 console_type_create_select_x ();
1466 #ifdef HAVE_MENUBARS
1467 console_type_create_menubar_x ();
1469 console_type_create_objects_x ();
1470 console_type_create_redisplay_x ();
1471 #ifdef HAVE_SCROLLBARS
1472 console_type_create_scrollbar_x ();
1474 #ifdef HAVE_TOOLBARS
1475 console_type_create_toolbar_x ();
1478 console_type_create_dialog_x ();
1480 #endif /* HAVE_X_WINDOWS */
1482 #ifdef HAVE_MS_WINDOWS
1483 console_type_create_mswindows ();
1484 console_type_create_device_mswindows ();
1485 console_type_create_frame_mswindows ();
1486 console_type_create_objects_mswindows ();
1487 console_type_create_redisplay_mswindows ();
1488 console_type_create_glyphs_mswindows ();
1489 console_type_create_select_mswindows ();
1490 # ifdef HAVE_SCROLLBARS
1491 console_type_create_scrollbar_mswindows ();
1493 #ifdef HAVE_MENUBARS
1494 console_type_create_menubar_mswindows ();
1496 #ifdef HAVE_TOOLBARS
1497 console_type_create_toolbar_mswindows ();
1500 console_type_create_dialog_mswindows ();
1504 /* Now initialize the specifier types and associated symbols.
1505 Other than the first function below, the functions may
1506 make exactly the following function/macro calls:
1508 INITIALIZE_SPECIFIER_TYPE()
1509 SPECIFIER_HAS_METHOD()
1511 For any given specifier type, the former macro must be called
1512 before the any calls to the latter macro. */
1514 specifier_type_create ();
1516 specifier_type_create_image ();
1517 specifier_type_create_gutter ();
1518 specifier_type_create_objects ();
1519 #ifdef HAVE_TOOLBARS
1520 specifier_type_create_toolbar ();
1523 /* Now initialize the structure types and associated symbols.
1524 Other than the first function below, the functions may
1525 make exactly the following function/macro calls:
1527 define_structure_type()
1528 define_structure_type_keyword()
1532 structure_type_create ();
1534 structure_type_create_chartab ();
1535 structure_type_create_faces ();
1536 structure_type_create_rangetab ();
1537 structure_type_create_hash_table ();
1539 /* Now initialize the image instantiator formats and associated symbols.
1540 Other than the first function below, the functions may
1541 make exactly the following function/macro calls:
1543 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT()
1544 IIFORMAT_HAS_METHOD()
1545 IIFORMAT_VALID_KEYWORD()
1547 For any given image instantiator format, the first macro must be
1548 called before the any calls to the other macros. */
1550 image_instantiator_format_create ();
1551 image_instantiator_format_create_glyphs_eimage ();
1552 image_instantiator_format_create_glyphs_widget ();
1554 image_instantiator_format_create_glyphs_tty ();
1556 #ifdef HAVE_X_WINDOWS
1557 image_instantiator_format_create_glyphs_x ();
1558 #endif /* HAVE_X_WINDOWS */
1559 #ifdef HAVE_MS_WINDOWS
1560 image_instantiator_format_create_glyphs_mswindows ();
1561 #endif /* HAVE_MSWINDOWS_WINDOWS */
1563 /* Now initialize the lstream types and associated symbols.
1564 Other than the first function below, the functions may
1565 make exactly the following function/macro calls:
1567 LSTREAM_HAS_METHOD()
1571 lstream_type_create ();
1573 lstream_type_create_file_coding ();
1575 #if defined (HAVE_MS_WINDOWS) && !defined(HAVE_MSG_SELECT)
1576 lstream_type_create_mswindows_selectable ();
1579 /* Initialize processes implementation.
1580 The functions may make exactly the following function/macro calls:
1582 PROCESS_HAS_METHOD()
1584 #ifdef HAVE_UNIX_PROCESSES
1585 process_type_create_unix ();
1587 #ifdef HAVE_WIN32_PROCESSES
1588 process_type_create_nt ();
1591 /* Now initialize most variables.
1593 These functions may do exactly the following:
1606 defsymbol(), if it's absolutely necessary and you're sure that
1607 the symbol isn't referenced anywhere else in the initialization
1609 Fset() on a symbol that is unbound
1610 assigning a symbol or constant value to a variable
1611 using a global variable that has been initialized
1612 earlier on in the same function
1614 Any of the object-creating functions in alloc.c: e.g.
1627 perhaps a few others.
1630 /* Now allow Fprovide() statements to be made. */
1631 init_provide_once ();
1633 /* Do that before any specifier creation (esp. vars_of_glyphs()) */
1634 vars_of_specifier ();
1639 vars_of_bytecode ();
1641 vars_of_callproc ();
1651 vars_of_console_stream ();
1658 #ifdef HAVE_DRAGNDROP
1659 vars_of_dragdrop ();
1666 #ifdef HAVE_X_WINDOWS
1667 vars_of_event_Xt ();
1669 #if defined(HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS))
1670 vars_of_event_tty ();
1672 #ifdef HAVE_MS_WINDOWS
1673 vars_of_event_mswindows ();
1675 vars_of_event_stream ();
1681 vars_of_floatfns ();
1682 vars_of_font_lock ();
1685 vars_of_glyphs_eimage ();
1686 vars_of_glyphs_widget ();
1694 vars_of_input_method_motif ();
1695 #else /* XIM_XLIB */
1696 vars_of_input_method_xlib ();
1698 #endif /* HAVE_XIM */
1704 #ifdef HAVE_DATABASE
1705 vars_of_database ();
1707 #ifdef HAVE_MENUBARS
1721 #ifndef NO_SUBPROCESSES
1723 #ifdef HAVE_UNIX_PROCESSES
1724 vars_of_process_unix ();
1726 #ifdef HAVE_WIN32_PROCESSES
1727 vars_of_process_nt ();
1732 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
1734 #endif /* HAVE_MMAP && REL_ALLOC */
1735 vars_of_redisplay ();
1736 #ifdef HAVE_SCROLLBARS
1737 vars_of_scrollbar ();
1744 #ifdef HAVE_TOOLBARS
1751 vars_of_console_tty ();
1752 vars_of_frame_tty ();
1753 vars_of_objects_tty ();
1756 #ifdef HAVE_X_WINDOWS
1757 #ifdef HAVE_BALLOON_HELP
1758 vars_of_balloon_x ();
1760 vars_of_device_x ();
1762 vars_of_dialog_x ();
1765 vars_of_glyphs_x ();
1766 #ifdef HAVE_MENUBARS
1767 vars_of_menubar_x ();
1769 vars_of_objects_x ();
1770 vars_of_select_x ();
1771 #ifdef HAVE_SCROLLBARS
1772 vars_of_scrollbar_x ();
1774 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
1777 #endif /* HAVE_X_WINDOWS */
1779 #ifdef HAVE_MS_WINDOWS
1780 vars_of_device_mswindows ();
1781 vars_of_console_mswindows ();
1782 vars_of_frame_mswindows ();
1783 vars_of_objects_mswindows ();
1784 vars_of_select_mswindows ();
1785 vars_of_glyphs_mswindows ();
1786 #ifdef HAVE_SCROLLBARS
1787 vars_of_scrollbar_mswindows ();
1789 #ifdef HAVE_MENUBARS
1790 vars_of_menubar_mswindows ();
1792 #ifdef HAVE_MSW_C_DIRED
1793 vars_of_dired_mswindows ();
1796 vars_of_dialog_mswindows ();
1798 #endif /* HAVE_MS_WINDOWS */
1802 vars_of_mule_ccl ();
1803 vars_of_mule_charset ();
1806 vars_of_file_coding ();
1810 vars_of_mule_wnn ();
1813 vars_of_mule_canna ();
1814 #endif /* HAVE_CANNA */
1818 vars_of_tooltalk ();
1829 #ifdef HAVE_POSTGRESQL
1830 vars_of_postgresql();
1834 vars_of_gpmevent ();
1837 /* Now initialize any specifier variables. We do this later
1838 because it has some dependence on the vars initialized
1841 These functions should *only* initialize specifier variables,
1842 and may make use of the following functions/macros in addition
1843 to the ones listed above:
1847 set_specifier_fallback()
1848 set_specifier_caching()
1851 specifier_vars_of_glyphs ();
1852 specifier_vars_of_gutter ();
1853 #ifdef HAVE_MENUBARS
1854 specifier_vars_of_menubar ();
1856 specifier_vars_of_redisplay ();
1857 #ifdef HAVE_SCROLLBARS
1858 specifier_vars_of_scrollbar ();
1860 #ifdef HAVE_TOOLBARS
1861 specifier_vars_of_toolbar ();
1863 specifier_vars_of_window ();
1865 /* Now comes all the rest of the variables that couldn't
1866 be handled above. There may be dependencies on variables
1867 initialized above, and dependencies between one complex_vars_()
1868 function and another. */
1870 /* Calls Fmake_range_table(). */
1871 complex_vars_of_regex ();
1872 /* Calls Fmake_range_table(). */
1873 complex_vars_of_search ();
1875 /* Calls make_lisp_hash_table(). */
1876 complex_vars_of_extents ();
1878 /* Depends on hash tables and specifiers. */
1879 complex_vars_of_faces ();
1882 /* These two depend on hash tables and various variables declared
1883 earlier. The second may also depend on the first. */
1884 complex_vars_of_mule_charset ();
1887 complex_vars_of_file_coding ();
1890 /* This calls allocate_glyph(), which creates specifiers
1891 and also relies on a variable (Vthe_nothing_vector) initialized
1892 above. It also calls make_ext_string(), which under Mule
1893 could require that the charsets be initialized. */
1894 complex_vars_of_glyphs ();
1896 /* These rely on the glyphs just created in the previous function,
1897 and call Fadd_spec_to_specifier(), which relies on various
1898 variables initialized above. */
1899 #ifdef HAVE_X_WINDOWS
1900 complex_vars_of_glyphs_x ();
1902 #ifdef HAVE_MS_WINDOWS
1903 complex_vars_of_glyphs_mswindows ();
1906 /* This calls Fmake_glyph_internal(). */
1907 complex_vars_of_alloc ();
1909 /* This calls Fmake_glyph_internal(). */
1910 #ifdef HAVE_MENUBARS
1911 complex_vars_of_menubar ();
1914 /* This calls Fmake_glyph_internal(). */
1915 #ifdef HAVE_SCROLLBARS
1916 complex_vars_of_scrollbar ();
1919 /* This calls allocate_glyph(). */
1920 complex_vars_of_frame ();
1922 /* This calls Fcopy_category_table() under Mule, which calls who
1924 complex_vars_of_chartab ();
1926 /* This calls set_string_char(), which (under Mule) depends on the
1927 charsets being initialized. */
1928 complex_vars_of_casetab ();
1930 /* This calls Fcopy_syntax_table(), which relies on char tables. */
1931 complex_vars_of_syntax ();
1933 /* This initializes buffer-local variables, sets things up so
1934 that buffers can be created, and creates a couple of basic
1935 buffers. This depends on Vstandard_syntax_table and
1936 Vstandard_category_table (initialized in the previous
1937 functions), as well as a whole horde of variables that may
1938 have been initialized above. */
1939 complex_vars_of_buffer ();
1941 /* This initializes console-local variables. */
1942 complex_vars_of_console ();
1944 /* This creates a couple more buffers, and depends on the
1945 previous function. */
1946 complex_vars_of_minibuf ();
1948 /* These two might call Ffile_name_as_directory(), which
1949 might depend on all sorts of things; I'm not sure. */
1950 complex_vars_of_emacs ();
1952 /* This creates a couple of basic keymaps and depends on Lisp
1953 hash tables and Ffset() (both of which depend on some variables
1954 initialized in the vars_of_*() section) and possibly other
1956 complex_vars_of_keymap ();
1958 /* Calls make_lisp_hash_table() and creates a keymap */
1959 complex_vars_of_event_stream ();
1961 #ifdef ERROR_CHECK_GC
1963 extern int always_gc;
1964 if (always_gc) /* purification debugging hack */
1965 garbage_collect_1 ();
1969 } else if (!restart) {
1970 reinit_alloc_once_early ();
1971 reinit_symbols_once_early ();
1972 reinit_opaque_once_early ();
1974 reinit_console_type_create_stream ();
1976 reinit_console_type_create_tty ();
1978 #ifdef HAVE_X_WINDOWS
1979 reinit_console_type_create_x ();
1980 reinit_console_type_create_device_x ();
1982 #ifdef HAVE_MS_WINDOWS
1983 reinit_console_type_create_mswindows ();
1986 reinit_specifier_type_create ();
1987 reinit_specifier_type_create_image ();
1988 reinit_specifier_type_create_gutter ();
1989 reinit_specifier_type_create_objects ();
1990 #ifdef HAVE_TOOLBARS
1991 reinit_specifier_type_create_toolbar ();
1994 structure_type_create ();
1996 structure_type_create_chartab ();
1997 structure_type_create_faces ();
1998 structure_type_create_rangetab ();
1999 structure_type_create_hash_table ();
2001 lstream_type_create ();
2003 lstream_type_create_file_coding ();
2005 #if defined (HAVE_MS_WINDOWS) && !defined(HAVE_MSG_SELECT)
2006 lstream_type_create_mswindows_selectable ();
2008 #ifdef HAVE_UNIX_PROCESSES
2009 process_type_create_unix ();
2011 #ifdef HAVE_WIN32_PROCESSES
2012 process_type_create_nt ();
2015 reinit_vars_of_buffer ();
2016 reinit_vars_of_console ();
2018 reinit_vars_of_debug ();
2020 reinit_vars_of_device ();
2021 reinit_vars_of_eval ();
2022 #ifdef HAVE_X_WINDOWS
2023 reinit_vars_of_event_Xt ();
2025 #if defined(HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS))
2026 reinit_vars_of_event_tty ();
2028 #ifdef HAVE_MS_WINDOWS
2029 reinit_vars_of_event_mswindows ();
2031 reinit_vars_of_event_stream ();
2032 reinit_vars_of_events ();
2033 reinit_vars_of_extents ();
2034 reinit_vars_of_fileio ();
2035 reinit_vars_of_font_lock ();
2036 reinit_vars_of_glyphs ();
2037 reinit_vars_of_glyphs_widget ();
2038 reinit_vars_of_insdel ();
2039 reinit_vars_of_lread ();
2040 reinit_vars_of_lstream ();
2041 reinit_vars_of_minibuf ();
2043 reinit_vars_of_module ();
2045 reinit_vars_of_objects ();
2046 reinit_vars_of_print ();
2047 reinit_vars_of_search ();
2048 reinit_vars_of_undo ();
2049 reinit_vars_of_window ();
2051 #ifdef HAVE_MS_WINDOWS
2052 reinit_vars_of_frame_mswindows ();
2055 #ifdef HAVE_X_WINDOWS
2056 reinit_vars_of_device_x ();
2057 #ifdef HAVE_SCROLLBARS
2058 reinit_vars_of_scrollbar_x ();
2060 #ifdef HAVE_MENUBARS
2061 reinit_vars_of_menubar_x ();
2063 reinit_vars_of_select_x ();
2064 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
2065 reinit_vars_of_gui_x ();
2067 #endif /* HAVE_X_WINDOWS */
2069 #if defined(MULE) && defined(HAVE_WNN)
2070 reinit_vars_of_mule_wnn ();
2073 reinit_complex_vars_of_buffer ();
2074 reinit_complex_vars_of_console ();
2075 reinit_complex_vars_of_minibuf ();
2080 /* CONGRATULATIONS!!! We have successfully initialized the Lisp
2085 /* Stuff that needs to be reset at run time. Order below should
2090 reinit_mule_category ();
2094 /* Now do further initialization/setup of stuff that is not needed by the
2095 syms_of_() routines. This involves stuff that only is enabled in
2096 an interactive run (redisplay, user input, etc.) and stuff that is
2097 not needed until we start loading Lisp code (the reader). A lot
2098 of this stuff involves querying the current environment and needs
2099 to be done both at dump time and at run time. */
2101 init_initial_directory(); /* get the directory to use for the
2102 "*scratch*" buffer, etc. */
2106 * For Win32, call init_environment() now, so that environment/registry
2107 * variables will be properly entered into Vprocess_environment.
2112 init_callproc (); /* Set up the process environment (so that egetenv
2113 works), the basic directory variables
2114 (exec-directory and so on), and stuff
2115 related to subprocesses. This should be
2116 first because many of the functions below
2117 call egetenv() to get environment variables. */
2118 init_lread (); /* Set up the Lisp reader. */
2119 init_cmdargs (argc, (Extbyte **) argv,
2120 skip_args); /* Create list Vcommand_line_args */
2121 init_buffer (); /* Set default directory of *scratch* buffer */
2127 init_redisplay (); /* Determine terminal type.
2128 init_sys_modes uses results */
2130 init_event_stream (); /* Set up so we can get user input. */
2131 init_macros (); /* set up so we can run macros. */
2132 init_editfns (); /* Determine the name of the user we're running as */
2133 init_xemacs_process (); /* set up for calling subprocesses */
2135 init_sunpro (); /* Set up Sunpro usage tracking */
2137 #if defined (WIN32_NATIVE) || defined (CYGWIN)
2140 #if defined (HAVE_NATIVE_SOUND) && defined (hp9000s800)
2146 init_console_stream (restart); /* Create the first console */
2148 /* try to get the actual pathname of the exec file we are running */
2151 Vinvocation_name = Fcar (Vcommand_line_args);
2152 if (XSTRING_DATA(Vinvocation_name)[0] == '-')
2154 /* XEmacs as a login shell, oh goody! */
2155 Vinvocation_name = build_string(getenv("SHELL"));
2157 Vinvocation_directory = Vinvocation_name;
2159 if (!NILP (Ffile_name_directory (Vinvocation_name)))
2161 /* invocation-name includes a directory component -- presumably it
2162 is relative to cwd, not $PATH */
2163 Vinvocation_directory = Fexpand_file_name (Vinvocation_name,
2165 Vinvocation_path = Qnil;
2169 Vinvocation_path = decode_env_path ("PATH", NULL);
2170 locate_file (Vinvocation_path, Vinvocation_name,
2171 Vlisp_EXEC_SUFFIXES,
2172 &Vinvocation_directory, X_OK);
2175 if (NILP (Vinvocation_directory))
2176 Vinvocation_directory = Vinvocation_name;
2178 Vinvocation_name = Ffile_name_nondirectory (Vinvocation_directory);
2179 Vinvocation_directory = Ffile_name_directory (Vinvocation_directory);
2182 #if defined(HAVE_SHLIB) && !defined(WIN32_NATIVE)
2183 /* This is Unix only. MS Windows NT has a library call that does
2184 The Right Thing on that system. Rumor has it, this must be
2185 called for GNU dld in temacs and xemacs. */
2187 char *buf = (char *)alloca (XSTRING_LENGTH (Vinvocation_directory)
2188 + XSTRING_LENGTH (Vinvocation_name)
2190 sprintf (buf, "%s/%s", XSTRING_DATA (Vinvocation_directory),
2191 XSTRING_DATA (Vinvocation_name));
2193 /* All we can do is cry if an error happens, so ignore it. */
2194 (void) dll_init (buf);
2198 #if defined (LOCALTIME_CACHE) && defined (HAVE_TZSET)
2199 /* sun's localtime() has a bug. it caches the value of the time
2200 zone rather than looking it up every time. Since localtime() is
2201 called to bolt the undumping time into the undumped emacs, this
2202 results in localtime() ignoring the TZ environment variable.
2203 This flushes the new TZ value into localtime(). */
2205 #endif /* LOCALTIME_CACHE and TZSET */
2210 /* Handle -l loadup-and-dump, args passed by Makefile. */
2211 if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
2212 load_me = build_string (argv[2 + skip_args]);
2213 #if 0 /* CANNOT_DUMP - this can never be right in XEmacs --andyp */
2214 /* Unless next switch is -nl, load "loadup.el" first thing. */
2215 if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
2216 load_me = build_string ("loadup.el");
2217 #endif /* CANNOT_DUMP */
2222 quantify_start_recording_data ();
2223 #endif /* QUANTIFY */
2227 /* This never returns. */
2228 initial_command_loop (load_me);
2233 /* Sort the args so we can find the most important ones
2234 at the beginning of argv. */
2236 /* First, here's a table of all the standard options. */
2238 struct standard_args
2241 const char *longname;
2246 static const struct standard_args standard_args[] =
2248 /* Handled by main_1 above: */
2249 { "-sd", "--show-dump-id", 105, 0 },
2250 { "-t", "--terminal", 100, 1 },
2251 { "-nd", "--no-dump-file", 95, 0 },
2252 { "-nw", "--no-windows", 90, 0 },
2253 { "-batch", "--batch", 85, 0 },
2254 { "-debug-paths", "--debug-paths", 82, 0 },
2255 { "-help", "--help", 80, 0 },
2256 { "-version", "--version", 75, 0 },
2258 { "-d", "--display", 80, 1 },
2259 { "-display", 0, 80, 1 },
2260 { "-NXHost", 0, 79, 0 },
2261 { "-MachLaunch", 0, 79, 0},
2263 /* Handled by command-line-early in startup.el: */
2264 { "-q", "--no-init-file", 50, 0 },
2265 { "-unmapped", 0, 50, 0 },
2266 { "-no-init-file", 0, 50, 0 },
2267 { "-vanilla", "--vanilla", 50, 0 },
2268 { "-no-autoloads", "--no-autoloads", 50, 0 },
2269 { "-no-site-file", "--no-site-file", 40, 0 },
2270 { "-no-early-packages", "--no-early-packages", 35, 0 },
2271 { "-u", "--user", 30, 1 },
2272 { "-user", 0, 30, 1 },
2273 { "-debug-init", "--debug-init", 20, 0 },
2274 { "-debug-paths", "--debug-paths", 20, 0 },
2277 { "-i", "--icon-type", 15, 0 },
2278 { "-itype", 0, 15, 0 },
2279 { "-iconic", "--iconic", 15, 0 },
2280 { "-bg", "--background-color", 10, 1 },
2281 { "-background", 0, 10, 1 },
2282 { "-fg", "--foreground-color", 10, 1 },
2283 { "-foreground", 0, 10, 1 },
2284 { "-bd", "--border-color", 10, 1 },
2285 { "-bw", "--border-width", 10, 1 },
2286 { "-ib", "--internal-border", 10, 1 },
2287 { "-ms", "--mouse-color", 10, 1 },
2288 { "-cr", "--cursor-color", 10, 1 },
2289 { "-fn", "--font", 10, 1 },
2290 { "-font", 0, 10, 1 },
2291 { "-g", "--geometry", 10, 1 },
2292 { "-geometry", 0, 10, 1 },
2293 { "-T", "--title", 10, 1 },
2294 { "-title", 0, 10, 1 },
2295 { "-name", "--name", 10, 1 },
2296 { "-xrm", "--xrm", 10, 1 },
2297 { "-r", "--reverse-video", 5, 0 },
2299 { "-reverse", 0, 5, 0 },
2300 { "-hb", "--horizontal-scroll-bars", 5, 0 },
2301 { "-vb", "--vertical-scroll-bars", 5, 0 },
2303 /* These have the same priority as ordinary file name args,
2304 so they are not reordered with respect to those. */
2305 { "-L", "--directory", 0, 1 },
2306 { "-directory", 0, 0, 1 },
2307 { "-l", "--load", 0, 1 },
2308 { "-load", 0, 0, 1 },
2309 { "-f", "--funcall", 0, 1 },
2310 { "-funcall", 0, 0, 1 },
2311 { "-eval", "--eval", 0, 1 },
2312 { "-insert", "--insert", 0, 1 },
2313 /* This should be processed after ordinary file name args and the like. */
2314 { "-kill", "--kill", -10, 0 },
2317 /* Reorder the elements of ARGV (assumed to have ARGC elements)
2318 so that the highest priority ones come first.
2319 Do not change the order of elements of equal priority.
2320 If an option takes an argument, keep it and its argument together. */
2323 sort_args (int argc, char **argv)
2325 char **new_argv = xnew_array (char *, argc);
2326 /* For each element of argv,
2327 the corresponding element of options is:
2328 0 for an option that takes no arguments,
2329 1 for an option that takes one argument, etc.
2330 -1 for an ordinary non-option argument. */
2331 int *options = xnew_array (int, argc);
2332 int *priority = xnew_array (int, argc);
2336 int end_of_options_p = 0;
2338 /* Categorize all the options,
2339 and figure out which argv elts are option arguments. */
2340 for (from = 1; from < argc; from++)
2344 /* Pseudo options "--" and "run-temacs" indicate end of options */
2345 if (!strcmp (argv[from], "--") ||
2346 !strcmp (argv[from], "run-temacs"))
2347 end_of_options_p = 1;
2348 if (!end_of_options_p && argv[from][0] == '-')
2353 /* Look for a match with a known old-fashioned option. */
2354 for (i = 0; i < countof (standard_args); i++)
2355 if (!strcmp (argv[from], standard_args[i].name))
2357 options[from] = standard_args[i].nargs;
2358 priority[from] = standard_args[i].priority;
2359 if (from + standard_args[i].nargs >= argc)
2360 fatal ("Option `%s' requires an argument\n", argv[from]);
2361 from += standard_args[i].nargs;
2365 /* Look for a match with a known long option.
2366 MATCH is -1 if no match so far, -2 if two or more matches so far,
2367 >= 0 (the table index of the match) if just one match so far. */
2368 if (argv[from][1] == '-')
2371 thislen = strlen (argv[from]);
2372 equals = strchr (argv[from], '=');
2374 thislen = equals - argv[from];
2376 for (i = 0; i < countof (standard_args); i++)
2377 if (standard_args[i].longname
2378 && !strncmp (argv[from], standard_args[i].longname,
2387 /* If we found exactly one match, use that. */
2390 options[from] = standard_args[match].nargs;
2391 priority[from] = standard_args[match].priority;
2392 /* If --OPTION=VALUE syntax is used,
2393 this option uses just one argv element. */
2396 if (from + options[from] >= argc)
2397 fatal ("Option `%s' requires an argument\n", argv[from]);
2398 from += options[from];
2405 /* Copy the arguments, in order of decreasing priority, to NEW_ARGV. */
2406 new_argv[0] = argv[0];
2410 int best_priority = -9999;
2412 /* Find the highest priority remaining option.
2413 If several have equal priority, take the first of them. */
2414 for (from = 1; from < argc; from++)
2416 if (argv[from] != 0 && priority[from] > best_priority)
2418 best_priority = priority[from];
2421 /* Skip option arguments--they are tied to the options. */
2422 if (options[from] > 0)
2423 from += options[from];
2429 /* Copy the highest priority remaining option, with its args, to NEW_ARGV. */
2430 new_argv[to++] = argv[best];
2431 for (i = 0; i < options[best]; i++)
2432 new_argv[to++] = argv[best + i + 1];
2434 /* Clear out this option in ARGV. */
2436 for (i = 0; i < options[best]; i++)
2437 argv[best + i + 1] = 0;
2440 memcpy (argv, new_argv, sizeof (char *) * argc);
2446 DEFUN ("running-temacs-p", Frunning_temacs_p, 0, 0, 0, /*
2447 True if running temacs. This means we are in the dumping stage.
2448 This is false during normal execution of the `xemacs' program, and
2449 becomes false once `run-emacs-from-temacs' is run.
2453 return run_temacs_argc >= 0 ? Qt : Qnil;
2456 DEFUN ("run-emacs-from-temacs", Frun_emacs_from_temacs, 0, MANY, 0, /*
2457 Do not call this. It will reinitialize your XEmacs. You'll be sorry.
2459 /* If this function is called from startup.el, it will be possible to run
2460 temacs as an editor using 'temacs -batch -l loadup.el run-temacs', instead
2461 of having to dump an emacs and then run that (when debugging emacs itself,
2462 this can be much faster)). [Actually, the speed difference isn't that
2463 much as long as your filesystem is local, and you don't end up with
2464 a dumped version in case you want to rerun it. This function is most
2465 useful when used as part of the `make all-elc' command. --ben]
2466 This will "restart" emacs with the specified command-line arguments.
2468 Martin thinks this function is most useful when using debugging
2469 tools like Purify or tcov that get confused by XEmacs' dumping. */
2470 (int nargs, Lisp_Object *args))
2473 const Extbyte *wampum;
2476 Lisp_Object orig_invoc_name = Fcar (Vcommand_line_args);
2477 const Extbyte **wampum_all = alloca_array (const Extbyte *, nargs);
2478 int *wampum_all_len = alloca_array (int, nargs);
2480 assert (!gc_in_progress);
2482 if (run_temacs_argc < 0)
2483 error ("I've lost my temacs-hood.");
2485 /* Need to convert the orig_invoc_name and all of the arguments
2486 to external format. */
2488 TO_EXTERNAL_FORMAT (LISP_STRING, orig_invoc_name,
2489 ALLOCA, (wampum, namesize),
2493 for (ac = 0, total_len = namesize; ac < nargs; ac++)
2495 CHECK_STRING (args[ac]);
2496 TO_EXTERNAL_FORMAT (LISP_STRING, args[ac],
2497 ALLOCA, (wampum_all[ac], wampum_all_len[ac]),
2499 wampum_all_len[ac]++;
2500 total_len += wampum_all_len[ac];
2502 DO_REALLOC (run_temacs_args, run_temacs_args_size, total_len, char);
2503 DO_REALLOC (run_temacs_argv, run_temacs_argv_size, nargs+2, char *);
2505 memcpy (run_temacs_args, wampum, namesize);
2506 run_temacs_argv [0] = run_temacs_args;
2507 for (ac = 0; ac < nargs; ac++)
2509 memcpy (run_temacs_args + namesize,
2510 wampum_all[ac], wampum_all_len[ac]);
2511 run_temacs_argv [ac + 1] = run_temacs_args + namesize;
2512 namesize += wampum_all_len[ac];
2514 run_temacs_argv [nargs + 1] = 0;
2515 catchlist = NULL; /* Important! Otherwise free_cons() calls in
2516 condition_case_unwind() may lead to GC death. */
2517 unbind_to (0, Qnil); /* this closes loadup.el */
2519 run_temacs_argc = nargs + 1;
2520 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2521 report_sheap_usage (0);
2523 LONGJMP (run_temacs_catch, 1);
2524 return Qnil; /* not reached; warning suppression */
2529 main (int argc, char **argv, char **envp)
2533 /* Under VC++, access violations and the like are not sent through
2534 the standard signal() mechanism. Rather, they need to be handled
2535 using the Microsoft "structured exception handling" mechanism,
2536 which vaguely resembles the C++ mechanisms. */
2541 int volatile vol_argc = argc;
2542 char ** volatile vol_argv = argv;
2543 char ** volatile vol_envp = envp;
2544 /* This is hairy. We need to compute where the XEmacs binary was invoked
2545 from because temacs initialization requires it to find the lisp
2546 directories. The code that recomputes the path is guarded by the
2547 restarted flag. There are three possible paths I've found so far
2550 temacs -- When running temacs for basic build stuff, the first main_1
2551 will be the only one invoked. It must compute the path else there
2552 will be a very ugly bomb in startup.el (can't find obvious location
2553 for doc-directory data-directory, etc.).
2555 temacs w/ run-temacs on the command line -- This is run to bytecompile
2556 all the out of date dumped lisp. It will execute both of the main_1
2557 calls and the second one must not touch the first computation because
2558 argc/argv are hosed the second time through.
2560 xemacs -- Only the second main_1 is executed. The invocation path must
2561 computed but this only matters when running in place or when running
2564 As a bonus for straightening this out, XEmacs can now be run in place
2565 as a login shell. This never used to work.
2567 As another bonus, we can now guarantee that
2568 (concat invocation-directory invocation-name) contains the filename
2569 of the XEmacs binary we are running. This can now be used in a
2570 definite test for out of date dumped files. -slb */
2573 quantify_stop_recording_data ();
2574 quantify_clear_data ();
2575 #endif /* QUANTIFY */
2577 suppress_early_error_handler_backtrace = 0;
2578 lim_data = 0; /* force reinitialization of this variable */
2580 /* Lisp_Object must fit in a word; check VALBITS and GCTYPEBITS */
2581 assert (sizeof (Lisp_Object) == sizeof (void *));
2583 #ifdef LINUX_SBRK_BUG
2589 #ifdef DOUG_LEA_MALLOC
2590 mallopt (M_MMAP_MAX, 0);
2592 run_temacs_argc = 0;
2593 if (! SETJMP (run_temacs_catch))
2595 main_1 (vol_argc, vol_argv, vol_envp, 0);
2597 /* run-emacs-from-temacs called */
2599 vol_argc = run_temacs_argc;
2600 vol_argv = run_temacs_argv;
2602 /* This makes absolutely no sense to anyone involved. There are
2603 several people using this stuff. We've compared versions on
2604 everything we can think of. We can find no difference.
2605 However, on both my systems environ is a plain old global
2606 variable initialized to zero. _environ is the one that
2607 contains pointers to the actual environment.
2609 Since we can't figure out the difference (and we're hours
2610 away from a release), this takes a very cowardly approach and
2611 is bracketed with both a system specific preprocessor test
2612 and a runtime "do you have this problem" test
2614 06/20/96 robertl@dgii.com */
2616 extern char **_environ;
2617 if ((unsigned) environ == 0)
2620 #endif /* _SCO_DS */
2623 #ifdef RUN_TIME_REMAP
2625 /* obviously no-one uses this because where it was before initialized was
2627 run_time_remap (argv[0]);
2630 #ifdef DOUG_LEA_MALLOC
2631 if (initialized && (malloc_state_ptr != NULL))
2633 int rc = malloc_set_state (malloc_state_ptr);
2636 stderr_out ("malloc_set_state failed, rc = %d\n", rc);
2640 free (malloc_state_ptr);
2642 /* mmap works in glibc-2.1, glibc-2.0 (Non-Mule only) and Linux libc5 */
2643 #if (defined(__GLIBC__) && __GLIBC_MINOR__ >= 1) || \
2644 defined(_NO_MALLOC_WARNING_) || \
2645 (defined(__GLIBC__) && __GLIBC_MINOR__ < 1 && !defined(MULE)) || \
2646 defined(DEBUG_DOUG_LEA_MALLOC)
2647 mallopt (M_MMAP_MAX, 64);
2653 #endif /* DOUG_LEA_MALLOC */
2655 run_temacs_argc = -1;
2657 main_1 (vol_argc, vol_argv, vol_envp, restarted);
2661 /* VC++ documentation says that
2662 GetExceptionCode() cannot be called inside the filter itself. */
2663 __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {}
2666 return 0; /* unreached */
2670 /* Dumping apparently isn't supported by versions of GCC >= 2.8. */
2671 /* The following needs conditionalization on whether either XEmacs or */
2672 /* various system shared libraries have been built and linked with */
2673 /* GCC >= 2.8. -slb */
2674 #if defined(GNU_MALLOC)
2676 voodoo_free_hook (void *mem)
2678 /* Disable all calls to free() when XEmacs is exiting and it doesn't */
2681 #ifdef __GNUC__ /* prototype of __free_hook varies with glibc version */
2682 (__typeof__ (__free_hook))
2686 #endif /* GNU_MALLOC */
2688 DEFUN ("kill-emacs", Fkill_emacs, 0, 1, "P", /*
2689 Exit the XEmacs job and kill it. Ask for confirmation, without argument.
2690 If ARG is an integer, return ARG as the exit program code.
2691 If ARG is a string, stuff it as keyboard input.
2693 The value of `kill-emacs-hook', if not void,
2694 is a list of functions (of no args),
2695 all of which are called before XEmacs is actually killed.
2699 /* This function can GC */
2700 struct gcpro gcpro1;
2707 if (!preparing_for_armageddon && !noninteractive)
2708 run_hook (Qkill_emacs_hook);
2710 ensure_no_quitting_from_now_on ();
2712 if (!preparing_for_armageddon)
2714 Lisp_Object concons, nextcons;
2716 /* Normally, go ahead and delete all the consoles now.
2717 Some unmentionably lame window systems (MS Wwwww...... eek,
2718 I can't even say it) don't properly clean up after themselves,
2719 and even for those that do, it might be cleaner this way.
2720 If we're going down, however, we don't do this (might
2721 be too dangerous), and if we get a crash somewhere within
2722 this loop, we'll still autosave and won't try this again. */
2724 LIST_LOOP_DELETING (concons, nextcons, Vconsole_list)
2726 /* There is very little point in deleting the stream console.
2727 It uses stdio, which should flush any buffered output and
2728 something can only go wrong. -slb */
2729 /* I changed my mind. There's a stupid hack in close to add
2730 a trailing newline. */
2731 /*if (!CONSOLE_STREAM_P (XCONSOLE (XCAR (concons))))*/
2732 delete_console_internal (XCONSOLE (XCAR (concons)), 1, 1, 0);
2738 #ifdef HAVE_MS_WINDOWS
2739 /* If we displayed a message on the console, then we must allow the
2740 user to see this message. This may be unnecessary, but can't hurt,
2741 and we can't necessarily check arg; e.g. xemacs --help kills with
2743 if (mswindows_message_outputted)
2744 Fmswindows_message_box (build_string ("Messages outputted. XEmacs is exiting."),
2748 shut_down_emacs (0, STRINGP (arg) ? arg : Qnil, 0);
2750 #if defined(GNU_MALLOC)
2752 #ifdef __GNUC__ /* prototype of __free_hook varies with glibc version */
2753 (__typeof__ (__free_hook))
2758 exit (INTP (arg) ? XINT (arg) : 0);
2760 return Qnil; /* I'm sick of the compiler warning */
2763 /* Perform an orderly shutdown of XEmacs. Autosave any modified
2764 buffers, kill any child processes, clean up the terminal modes (if
2765 we're in the foreground), and other stuff like that. Don't perform
2766 any redisplay; this may be called when XEmacs is shutting down in
2767 the background, or after its X connection has died.
2769 If SIG is a signal number, print a message for it.
2771 This is called by fatal signal handlers and Fkill_emacs. It used to
2772 be called by X protocol error handlers, but instead they now call
2775 shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save)
2777 /* This function can GC */
2778 /* Prevent running of hooks and other non-essential stuff
2780 preparing_for_armageddon = 1;
2782 ensure_no_quitting_from_now_on ();
2785 quantify_stop_recording_data ();
2786 #endif /* QUANTIFY */
2788 /* This is absolutely the most important thing to do, so make sure
2789 we do it now, before anything else. We might have crashed and
2790 be in a weird inconsistent state, and potentially anything could
2791 set off another protection fault and cause us to bail out
2793 /* Steve writes the following:
2795 [[I'm not removing the code entirely, yet. We have run up against
2796 a spate of problems in diagnosing crashes due to crashes within
2797 crashes. It has very definitely been determined that code called
2798 during auto-saving cannot work if XEmacs crashed inside of GC.
2799 We already auto-save on an itimer so there cannot be too much
2800 unsaved stuff around, and if we get better crash reports we might
2801 be able to get more problems fixed so I'm disabling this. -slb]]
2803 and DISABLES AUTO-SAVING ENTIRELY during crashes! Way way bad idea.
2805 Instead let's just be more intelligent about avoiding crashing
2806 when possible, esp. nested crashes.
2809 Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
2812 reset_all_consoles ();
2813 if (sig && sig != SIGTERM)
2816 stderr_out ("\nFatal error.\n\n");
2818 stderr_out ("\nFatal error (%d).\n\n", sig);
2820 ("Your files have been auto-saved.\n"
2821 "Use `M-x recover-session' to recover them.\n"
2823 "If you have access to the PROBLEMS file that came with your\n"
2824 "version of XEmacs, please check to see if your crash is described\n"
2825 "there, as there may be a workaround available.\n"
2827 "Otherwise, please report this bug by selecting `Report-Bug'\n"
2828 "in the InfoDock menu.\n"
2830 "Otherwise, please report this bug by running the send-pr\n"
2831 "script included with XEmacs, or selecting `Send Bug Report'\n"
2832 "from the help menu.\n"
2833 "As a last resort send ordinary email to `crashes@xemacs.org'.\n"
2835 "*MAKE SURE* to include the information in the command\n"
2836 "M-x describe-installation.\n"
2839 "If at all possible, *please* try to obtain a C stack backtrace;\n"
2840 "it will help us immensely in determining what went wrong.\n"
2841 "To do this, locate the core file that was produced as a result\n"
2842 "of this crash (it's usually called `core' and is located in the\n"
2843 "directory in which you started the editor, or maybe in your home\n"
2844 "directory), and type\n"
2854 /* Now try to determine the actual path to the executable,
2855 to try to make the backtrace-determination process as foolproof
2857 if (STRINGP (Vinvocation_name))
2858 name = (char *) XSTRING_DATA (Vinvocation_name);
2861 if (STRINGP (Vinvocation_directory))
2862 dir = (char *) XSTRING_DATA (Vinvocation_directory);
2863 if (!dir || dir[0] != '/')
2864 stderr_out ("`which %s`", name);
2865 else if (dir[strlen (dir) - 1] != '/')
2866 stderr_out ("%s/%s", dir, name);
2868 stderr_out ("%s%s", dir, name);
2872 "then type `where' when the debugger prompt comes up.\n"
2873 "(If you don't have GDB on your system, you might have DBX,\n"
2874 "or XDB, or SDB. A similar procedure should work for all of\n"
2875 "these. Ask your system administrator if you need more help.)\n");
2876 #endif /* _MSC_VER */
2879 stuff_buffered_input (stuff);
2881 kill_buffer_processes (Qnil);
2883 #ifdef CLASH_DETECTION
2884 unlock_all_files ();
2888 tt_session_quit (tt_default_session ());
2890 /* The following crashes when built on X11R5 and run on X11R6 */
2893 #endif /* TOOLTALK */
2900 #if !defined(PDUMP) || !defined(SYSTEM_MALLOC)
2901 extern char my_edata[];
2904 extern void disable_free_hook (void);
2906 DEFUN ("dump-emacs", Fdump_emacs, 2, 2, 0, /*
2907 Dump current state of XEmacs into executable file FILENAME.
2908 Take symbols from SYMFILE (presumably the file you executed to run XEmacs).
2909 This is used in the file `loadup.el' when building XEmacs.
2911 Remember to set `command-line-processed' to nil before dumping
2912 if you want the dumped XEmacs to process its command line
2913 and announce itself normally when it is run.
2915 (intoname, symname))
2917 /* This function can GC */
2918 struct gcpro gcpro1, gcpro2;
2921 GCPRO2 (intoname, symname);
2923 #ifdef FREE_CHECKING
2924 Freally_free (Qnil);
2926 /* When we're dumping, we can't use the debugging free() */
2927 disable_free_hook ();
2930 CHECK_STRING (intoname);
2931 intoname = Fexpand_file_name (intoname, Qnil);
2932 if (!NILP (symname))
2934 CHECK_STRING (symname);
2935 if (XSTRING_LENGTH (symname) > 0)
2936 symname = Fexpand_file_name (symname, Qnil);
2941 opurify = purify_flag;
2944 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2945 report_sheap_usage (1);
2953 disksave_object_finalization ();
2954 release_breathing_space ();
2956 /* Tell malloc where start of impure now is */
2957 /* Also arrange for warnings when nearly out of space. */
2958 #ifndef SYSTEM_MALLOC
2959 memory_warnings (my_edata, malloc_warning);
2968 LISP_STRING_TO_EXTERNAL (intoname, intoname_ext, Qfile_name);
2970 if (STRINGP (symname))
2971 LISP_STRING_TO_EXTERNAL (symname, symname_ext, Qfile_name);
2975 garbage_collect_1 ();
2981 #ifdef DOUG_LEA_MALLOC
2982 malloc_state_ptr = malloc_get_state ();
2984 /* here we break our rule that the filename conversion should
2985 be performed at the actual time that the system call is made.
2986 It's a whole lot easier to do the conversion here than to
2987 modify all the unexec routines to ensure that filename
2988 conversion is applied everywhere. Don't worry about memory
2989 leakage because this call only happens once. */
2990 unexec (intoname_ext, symname_ext, (uintptr_t) my_edata, 0, 0);
2991 #ifdef DOUG_LEA_MALLOC
2992 free (malloc_state_ptr);
2994 #endif /* not PDUMP */
2997 purify_flag = opurify;
3002 #endif /* not CANNOT_DUMP */
3005 /* Split STRING into a list of substrings. The substrings are the
3006 parts of original STRING separated by SEPCHAR. */
3008 split_string_by_emchar_1 (const Bufbyte *string, Bytecount size,
3011 Lisp_Object result = Qnil;
3012 const Bufbyte *end = string + size;
3016 const Bufbyte *p = string;
3019 if (charptr_emchar (p) == sepchar)
3023 result = Fcons (make_string (string, p - string), result);
3027 INC_CHARPTR (string); /* skip sepchar */
3032 return Fnreverse (result);
3035 /* The same as the above, except PATH is an external C string (it is
3036 converted using Qfile_name), and sepchar is hardcoded to SEPCHAR
3037 (':' or whatever). */
3039 decode_path (const char *path)
3046 TO_INTERNAL_FORMAT (C_STRING, path, ALLOCA, (newpath, newlen), Qfile_name);
3048 /* #### Does this make sense? It certainly does for
3049 decode_env_path(), but it looks dubious here. Does any code
3050 depend on decode_path("") returning nil instead of an empty
3055 return split_string_by_emchar_1 (newpath, newlen, SEPCHAR);
3059 decode_env_path (const char *evarname, const char *default_)
3061 const char *path = 0;
3063 path = egetenv (evarname);
3066 return decode_path (path);
3069 /* Ben thinks this function should not exist or be exported to Lisp.
3070 We use it to define split-path-string in subr.el (not!). */
3072 DEFUN ("split-string-by-char", Fsplit_string_by_char, 1, 2, 0, /*
3073 Split STRING into a list of substrings originally separated by SEPCHAR.
3077 CHECK_STRING (string);
3078 CHECK_CHAR (sepchar);
3079 return split_string_by_emchar_1 (XSTRING_DATA (string),
3080 XSTRING_LENGTH (string),
3084 /* #### This was supposed to be in subr.el, but is used VERY early in
3085 the bootstrap process, so it goes here. Damn. */
3087 DEFUN ("split-path", Fsplit_path, 1, 1, 0, /*
3088 Explode a search path into a list of strings.
3089 The path components are separated with the characters specified
3090 with `path-separator'.
3094 CHECK_STRING (path);
3096 while (!STRINGP (Vpath_separator)
3097 || (XSTRING_CHAR_LENGTH (Vpath_separator) != 1))
3098 Vpath_separator = signal_simple_continuable_error
3099 ("`path-separator' should be set to a single-character string",
3102 return (split_string_by_emchar_1
3103 (XSTRING_DATA (path), XSTRING_LENGTH (path),
3104 charptr_emchar (XSTRING_DATA (Vpath_separator))));
3107 DEFUN ("noninteractive", Fnoninteractive, 0, 0, 0, /*
3108 Non-nil return value means XEmacs is running without interactive terminal.
3112 return noninteractive ? Qt : Qnil;
3115 /* This flag is useful to define if you're under a debugger; this way, you
3116 can put a breakpoint of assert_failed() and debug multiple problems
3117 in one session without having to recompile. */
3118 /* #define ASSERTIONS_DONT_ABORT */
3120 #ifdef USE_ASSERTIONS
3121 /* This highly dubious kludge ... shut up Jamie, I'm tired of your slagging. */
3123 static int in_assert_failed;
3124 static const char *assert_failed_file;
3125 static int assert_failed_line;
3126 static const char *assert_failed_expr;
3132 #undef abort /* avoid infinite #define loop... */
3134 #if defined (WIN32_NATIVE) && defined (DEBUG_XEMACS)
3135 #define enter_debugger() DebugBreak ()
3137 #define enter_debugger()
3141 assert_failed (const char *file, int line, const char *expr)
3143 /* If we're already crashing, let's not crash again. This might be
3144 critical to getting auto-saving working properly. */
3145 if (fatal_error_in_progress)
3148 /* We are extremely paranoid so we sensibly deal with recursive
3149 assertion failures. */
3152 if (in_assert_failed >= 4)
3154 else if (in_assert_failed == 3)
3159 else if (in_assert_failed == 2)
3161 /* Not stderr_out(), which does additional things and may trigger
3162 a recursive assertion failure. fprintf was undeffed above, in
3163 case it was encapsulated. */
3165 "Fatal error: recursive assertion failure, "
3166 "file %s, line %d, %s\n",
3169 "Original assertion failure: file %s, line %d, %s\n",
3170 assert_failed_file, assert_failed_line, assert_failed_expr);
3174 assert_failed_file = file;
3175 assert_failed_line = line;
3176 assert_failed_expr = expr;
3180 "Fatal error: assertion failed, file %s, line %d, %s\n",
3183 stderr_out ("Fatal error: assertion failed, file %s, line %d, %s\n",
3188 #if !defined (ASSERTIONS_DONT_ABORT)
3191 in_assert_failed = 0;
3193 #endif /* USE_ASSERTIONS */
3196 DEFUN ("quantify-start-recording-data", Fquantify_start_recording_data,
3198 Start recording Quantify data.
3202 quantify_start_recording_data ();
3206 DEFUN ("quantify-stop-recording-data", Fquantify_stop_recording_data,
3208 Stop recording Quantify data.
3212 quantify_stop_recording_data ();
3216 DEFUN ("quantify-clear-data", Fquantify_clear_data, 0, 0, "", /*
3217 Clear all Quantify data.
3221 quantify_clear_data ();
3224 #endif /* QUANTIFY */
3227 syms_of_emacs (void)
3230 DEFSUBR (Fdump_emacs);
3231 #endif /* !CANNOT_DUMP */
3233 DEFSUBR (Frun_emacs_from_temacs);
3234 DEFSUBR (Frunning_temacs_p);
3235 DEFSUBR (Finvocation_name);
3236 DEFSUBR (Finvocation_directory);
3237 DEFSUBR (Fkill_emacs);
3238 DEFSUBR (Fnoninteractive);
3241 DEFSUBR (Fquantify_start_recording_data);
3242 DEFSUBR (Fquantify_stop_recording_data);
3243 DEFSUBR (Fquantify_clear_data);
3244 #endif /* QUANTIFY */
3246 DEFSUBR (Fsplit_string_by_char);
3247 DEFSUBR (Fsplit_path); /* #### */
3249 defsymbol (&Qkill_emacs_hook, "kill-emacs-hook");
3250 defsymbol (&Qsave_buffers_kill_emacs, "save-buffers-kill-emacs");
3254 vars_of_emacs (void)
3256 DEFVAR_BOOL ("suppress-early-error-handler-backtrace",
3257 &suppress_early_error_handler_backtrace /*
3258 Non-nil means early error handler shouldn't print a backtrace.
3261 DEFVAR_LISP ("command-line-args", &Vcommand_line_args /*
3262 Args passed by shell to XEmacs, as a list of strings.
3265 DEFVAR_LISP ("invocation-name", &Vinvocation_name /*
3266 The program name that was used to run XEmacs.
3267 Any directory names are omitted.
3270 DEFVAR_LISP ("invocation-directory", &Vinvocation_directory /*
3271 The directory in which the XEmacs executable was found, to run it.
3272 The value is simply the program name if that directory's name is not known.
3275 DEFVAR_LISP ("invocation-path", &Vinvocation_path /*
3276 The path in which the XEmacs executable was found, to run it.
3277 The value is simply the value of environment variable PATH on startup
3278 if XEmacs was found there.
3282 xxDEFVAR_LISP ("installation-directory", &Vinstallation_directory,
3283 "A directory within which to look for the `lib-src' and `etc' directories.\n"
3284 "This is non-nil when we can't find those directories in their standard\n"
3285 "installed locations, but we can find them\n"
3286 "near where the XEmacs executable was found.");
3289 DEFVAR_LISP ("system-type", &Vsystem_type /*
3290 Symbol indicating type of operating system you are using.
3292 Vsystem_type = intern (SYSTEM_TYPE);
3293 Fprovide (intern(SYSTEM_TYPE));
3295 #ifndef EMACS_CONFIGURATION
3296 # define EMACS_CONFIGURATION "UNKNOWN"
3298 DEFVAR_LISP ("system-configuration", &Vsystem_configuration /*
3299 String naming the configuration XEmacs was built for.
3301 Vsystem_configuration = build_string (EMACS_CONFIGURATION);
3303 #ifndef EMACS_CONFIG_OPTIONS
3304 # define EMACS_CONFIG_OPTIONS "UNKNOWN"
3306 DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options /*
3307 String containing the configuration options XEmacs was built with.
3309 Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS);
3311 DEFVAR_LISP ("emacs-major-version", &Vemacs_major_version /*
3312 Major version number of this version of Emacs, as an integer.
3313 Warning: this variable did not exist in Emacs versions earlier than:
3317 Vemacs_major_version = make_int (EMACS_MAJOR_VERSION);
3319 DEFVAR_LISP ("emacs-minor-version", &Vemacs_minor_version /*
3320 Minor version number of this version of Emacs, as an integer.
3321 Warning: this variable did not exist in Emacs versions earlier than:
3325 Vemacs_minor_version = make_int (EMACS_MINOR_VERSION);
3327 DEFVAR_LISP ("emacs-patch-level", &Vemacs_patch_level /*
3328 The patch level of this version of Emacs, as an integer.
3329 The value is non-nil if this version of XEmacs is part of a series of
3330 stable XEmacsen, but has bug fixes applied.
3331 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3334 #ifdef EMACS_PATCH_LEVEL
3335 Vemacs_patch_level = make_int (EMACS_PATCH_LEVEL);
3337 Vemacs_patch_level = Qnil;
3340 DEFVAR_LISP ("emacs-beta-version", &Vemacs_beta_version /*
3341 Beta number of this version of Emacs, as an integer.
3342 The value is nil if this is an officially released version of XEmacs.
3343 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3346 #ifdef EMACS_BETA_VERSION
3347 Vemacs_beta_version = make_int (EMACS_BETA_VERSION);
3349 Vemacs_beta_version = Qnil;
3353 DEFVAR_LISP ("infodock-major-version", &Vinfodock_major_version /*
3354 Major version number of this InfoDock release.
3356 Vinfodock_major_version = make_int (INFODOCK_MAJOR_VERSION);
3358 DEFVAR_LISP ("infodock-minor-version", &Vinfodock_minor_version /*
3359 Minor version number of this InfoDock release.
3361 Vinfodock_minor_version = make_int (INFODOCK_MINOR_VERSION);
3363 DEFVAR_LISP ("infodock-build-version", &Vinfodock_build_version /*
3364 Build version of this InfoDock release.
3366 Vinfodock_build_version = make_int (INFODOCK_BUILD_VERSION);
3369 DEFVAR_LISP ("xemacs-codename", &Vxemacs_codename /*
3370 Codename of this version of Emacs (a string).
3372 #ifndef XEMACS_CODENAME
3373 #define XEMACS_CODENAME "Noname"
3375 Vxemacs_codename = build_string (XEMACS_CODENAME);
3377 /* Lisp variables which contain command line flags.
3379 The portable dumper stomps on these; they must be saved and restored
3380 if they are processed before the call to pdump_load() in main_1().
3382 DEFVAR_BOOL ("noninteractive", &noninteractive1 /*
3383 Non-nil means XEmacs is running without interactive terminal.
3386 DEFVAR_BOOL ("inhibit-early-packages", &inhibit_early_packages /*
3387 Set to non-nil when the early packages should not be respected at startup.
3390 DEFVAR_BOOL ("inhibit-autoloads", &inhibit_autoloads /*
3391 Set to non-nil when autoloads should not be loaded at startup.
3394 DEFVAR_BOOL ("debug-paths", &debug_paths /*
3395 Set to non-nil when debug information about paths should be printed.
3398 DEFVAR_BOOL ("inhibit-site-lisp", &inhibit_site_lisp /*
3399 Set to non-nil when the site-lisp should not be searched at startup.
3401 #ifdef INHIBIT_SITE_LISP
3402 inhibit_site_lisp = 1;
3405 DEFVAR_BOOL ("inhibit-site-modules", &inhibit_site_modules /*
3406 Set to non-nil when site-modules should not be searched at startup.
3408 #ifdef INHIBIT_SITE_MODULES
3409 inhibit_site_modules = 1;
3412 DEFVAR_INT ("emacs-priority", &emacs_priority /*
3413 Priority for XEmacs to run at.
3414 This value is effective only if set before XEmacs is dumped,
3415 and only if the XEmacs executable is installed with setuid to permit
3416 it to change priority. (XEmacs sets its uid back to the real uid.)
3417 Currently, you need to define SET_EMACS_PRIORITY in `config.h'
3418 before you compile XEmacs, to enable the code for this feature.
3422 DEFVAR_CONST_LISP ("internal-error-checking", &Vinternal_error_checking /*
3423 Internal error checking built-in into this instance of XEmacs.
3424 This is a list of symbols, initialized at build-time. Legal symbols
3427 extents - check extents prior to each extent change;
3428 typecheck - check types strictly, aborting in case of error;
3429 malloc - check operation of malloc;
3430 gc - check garbage collection;
3431 bufpos - check buffer positions.
3433 quick-build - user has requested the "quick-build" configure option.
3435 Vinternal_error_checking = Qnil;
3436 #ifdef ERROR_CHECK_EXTENTS
3437 Vinternal_error_checking = Fcons (intern ("extents"),
3438 Vinternal_error_checking);
3440 #ifdef ERROR_CHECK_TYPECHECK
3441 Vinternal_error_checking = Fcons (intern ("typecheck"),
3442 Vinternal_error_checking);
3444 #ifdef ERROR_CHECK_MALLOC
3445 Vinternal_error_checking = Fcons (intern ("malloc"),
3446 Vinternal_error_checking);
3448 #ifdef ERROR_CHECK_GC
3449 Vinternal_error_checking = Fcons (intern ("gc"),
3450 Vinternal_error_checking);
3452 #ifdef ERROR_CHECK_BUFPOS
3453 Vinternal_error_checking = Fcons (intern ("bufpos"),
3454 Vinternal_error_checking);
3457 Vinternal_error_checking = Fcons (intern ("quick-build"),
3458 Vinternal_error_checking);
3461 DEFVAR_CONST_LISP ("mail-lock-methods", &Vmail_lock_methods /*
3462 Mail spool locking methods supported by this instance of XEmacs.
3463 This is a list of symbols. Each of the symbols is one of the
3464 following: dot, lockf, flock, locking, mmdf.
3467 Vmail_lock_methods = Qnil;
3468 Vmail_lock_methods = Fcons (intern ("dot"), Vmail_lock_methods);
3470 Vmail_lock_methods = Fcons (intern ("lockf"), Vmail_lock_methods);
3473 Vmail_lock_methods = Fcons (intern ("flock"), Vmail_lock_methods);
3476 Vmail_lock_methods = Fcons (intern ("mmdf"), Vmail_lock_methods);
3479 Vmail_lock_methods = Fcons (intern ("locking"), Vmail_lock_methods);
3483 DEFVAR_CONST_LISP ("configure-mail-lock-method", &Vconfigure_mail_lock_method /*
3484 Mail spool locking method suggested by configure. This is one
3485 of the symbols in MAIL-LOCK-METHODS.
3488 #if defined(MAIL_LOCK_FLOCK) && defined(HAVE_FLOCK)
3489 Vconfigure_mail_lock_method = intern("flock");
3490 #elif defined(MAIL_LOCK_LOCKF) && defined(HAVE_LOCKF)
3491 Vconfigure_mail_lock_method = intern("lockf");
3492 #elif defined(MAIL_LOCK_MMDF) && defined(HAVE_MMDF)
3493 Vconfigure_mail_lock_method = intern("mmdf");
3494 #elif defined(MAIL_LOCK_LOCKING) && defined(HAVE_LOCKING)
3495 Vconfigure_mail_lock_method = intern("locking");
3497 Vconfigure_mail_lock_method = intern("dot");
3501 DEFVAR_LISP ("path-separator", &Vpath_separator /*
3502 The directory separator in search paths, as a string.
3506 Vpath_separator = make_string ((Bufbyte *)&c, 1);
3511 complex_vars_of_emacs (void)
3513 /* This is all related to path searching. */
3515 DEFVAR_LISP ("emacs-program-name", &Vemacs_program_name /*
3516 *Name of the Emacs variant.
3517 For example, this may be \"xemacs\" or \"infodock\".
3518 This is mainly meant for use in path searching.
3520 Vemacs_program_name = build_string ((char *) PATH_PROGNAME);
3522 DEFVAR_LISP ("emacs-program-version", &Vemacs_program_version /*
3523 *Version of the Emacs variant.
3524 This typically has the form XX.XX[-bXX].
3525 This is mainly meant for use in path searching.
3527 Vemacs_program_version = build_string ((char *) PATH_VERSION);
3529 DEFVAR_LISP ("exec-path", &Vexec_path /*
3530 *List of directories to search programs to run in subprocesses.
3531 Each element is a string (directory name) or nil (try default directory).
3535 DEFVAR_LISP ("exec-directory", &Vexec_directory /*
3536 *Directory of architecture-dependent files that come with XEmacs,
3537 especially executable programs intended for XEmacs to invoke.
3539 Vexec_directory = Qnil;
3541 DEFVAR_LISP ("configure-exec-directory", &Vconfigure_exec_directory /*
3542 For internal use by the build procedure only.
3543 configure's idea of what EXEC-DIRECTORY will be.
3546 Vconfigure_exec_directory = Ffile_name_as_directory
3547 (build_string ((char *) PATH_EXEC));
3549 Vconfigure_exec_directory = Qnil;
3552 DEFVAR_LISP ("lisp-directory", &Vlisp_directory /*
3553 *Directory of core Lisp files that come with XEmacs.
3555 Vlisp_directory = Qnil;
3557 DEFVAR_LISP ("configure-lisp-directory", &Vconfigure_lisp_directory /*
3558 For internal use by the build procedure only.
3559 configure's idea of what LISP-DIRECTORY will be.
3561 #ifdef PATH_LOADSEARCH
3562 Vconfigure_lisp_directory = Ffile_name_as_directory
3563 (build_string ((char *) PATH_LOADSEARCH));
3565 Vconfigure_lisp_directory = Qnil;
3568 DEFVAR_LISP ("module-directory", &Vmodule_directory /*
3569 *Directory of core dynamic modules that come with XEmacs.
3571 Vmodule_directory = Qnil;
3573 DEFVAR_LISP ("configure-module-directory", &Vconfigure_module_directory /*
3574 For internal use by the build procedure only.
3575 configure's idea of what MODULE-DIRECTORY will be.
3577 #ifdef PATH_MODULESEARCH
3578 Vconfigure_module_directory = Ffile_name_as_directory
3579 (build_string ((char *) PATH_MODULESEARCH));
3581 Vconfigure_module_directory = Qnil;
3584 DEFVAR_LISP ("configure-package-path", &Vconfigure_package_path /*
3585 For internal use by the build procedure only.
3586 configure's idea of what the package path will be.
3588 #ifdef PATH_PACKAGEPATH
3589 Vconfigure_package_path = decode_path (PATH_PACKAGEPATH);
3591 Vconfigure_package_path = Qnil;
3594 DEFVAR_LISP ("data-directory", &Vdata_directory /*
3595 *Directory of architecture-independent files that come with XEmacs,
3596 intended for XEmacs to use.
3597 Use of this variable in new code is almost never correct. See the
3598 functions `locate-data-file' and `locate-data-directory' and the variable
3599 `data-directory-list'.
3601 Vdata_directory = Qnil;
3603 DEFVAR_LISP ("configure-data-directory", &Vconfigure_data_directory /*
3604 For internal use by the build procedure only.
3605 configure's idea of what DATA-DIRECTORY will be.
3608 Vconfigure_data_directory = Ffile_name_as_directory
3609 (build_string ((char *) PATH_DATA));
3611 Vconfigure_data_directory = Qnil;
3614 DEFVAR_LISP ("data-directory-list", &Vdata_directory_list /*
3615 *List of directories of architecture-independent files that come with XEmacs
3616 or were installed as packages, and are intended for XEmacs to use.
3618 Vdata_directory_list = Qnil;
3620 DEFVAR_LISP ("site-directory", &Vsite_directory /*
3621 *Directory of site-specific Lisp files that come with XEmacs.
3623 Vsite_directory = Qnil;
3625 DEFVAR_LISP ("configure-site-directory", &Vconfigure_site_directory /*
3626 For internal use by the build procedure only.
3627 configure's idea of what SITE-DIRECTORY will be.
3630 Vconfigure_site_directory = Ffile_name_as_directory
3631 (build_string ((char *) PATH_SITE));
3633 Vconfigure_site_directory = Qnil;
3636 DEFVAR_LISP ("site-module-directory", &Vsite_module_directory /*
3637 *Directory of site-specific loadable modules that come with XEmacs.
3639 Vsite_module_directory = Qnil;
3641 DEFVAR_LISP ("configure-site-module-directory", &Vconfigure_site_module_directory /*
3642 For internal use by the build procedure only.
3643 configure's idea of what SITE-DIRECTORY will be.
3645 #ifdef PATH_SITE_MODULES
3646 Vconfigure_site_module_directory = Ffile_name_as_directory
3647 (build_string ((char *) PATH_SITE_MODULES));
3649 Vconfigure_site_module_directory = Qnil;
3652 DEFVAR_LISP ("doc-directory", &Vdoc_directory /*
3653 *Directory containing the DOC file that comes with XEmacs.
3654 This is usually the same as exec-directory.
3656 Vdoc_directory = Qnil;
3658 DEFVAR_LISP ("configure-doc-directory", &Vconfigure_doc_directory /*
3659 For internal use by the build procedure only.
3660 configure's idea of what DOC-DIRECTORY will be.
3663 Vconfigure_doc_directory = Ffile_name_as_directory
3664 (build_string ((char *) PATH_DOC));
3666 Vconfigure_doc_directory = Qnil;
3669 DEFVAR_LISP ("configure-exec-prefix-directory", &Vconfigure_exec_prefix_directory /*
3670 For internal use by the build procedure only.
3671 configure's idea of what EXEC-PREFIX-DIRECTORY will be.
3673 #ifdef PATH_EXEC_PREFIX
3674 Vconfigure_exec_prefix_directory = Ffile_name_as_directory
3675 (build_string ((char *) PATH_EXEC_PREFIX));
3677 Vconfigure_exec_prefix_directory = Qnil;
3680 DEFVAR_LISP ("configure-prefix-directory", &Vconfigure_prefix_directory /*
3681 For internal use by the build procedure only.
3682 configure's idea of what PREFIX-DIRECTORY will be.
3685 Vconfigure_prefix_directory = Ffile_name_as_directory
3686 (build_string ((char *) PATH_PREFIX));
3688 Vconfigure_prefix_directory = Qnil;
3691 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory /*
3692 For internal use by the build procedure only.
3693 This is the name of the directory in which the build procedure installed
3694 Emacs's info files; the default value for Info-default-directory-list
3698 Vconfigure_info_directory =
3699 Ffile_name_as_directory (build_string (PATH_INFO));
3701 Vconfigure_info_directory = Qnil;
3704 DEFVAR_LISP ("configure-info-path", &Vconfigure_info_path /*
3705 The configured initial path for info documentation.
3707 #ifdef PATH_INFOPATH
3708 Vconfigure_info_path = decode_path (PATH_INFOPATH);
3710 Vconfigure_info_path = Qnil;
3714 #if defined(__sgi) && !defined(PDUMP)
3715 /* This is so tremendously ugly I'd puke. But then, it works.
3716 * The target is to override the static constructor from the
3717 * libiflPNG.so library which is masquerading as libz, and
3718 * cores on us when re-started from the dumped executable.
3719 * This will have to go for 21.1 -- OG.
3721 void __sti__iflPNGFile_c___(void);
3722 void __sti__iflPNGFile_c___()