(U-000221C7): Add `sound@ja/on'; integrate BC-8BD8.
[chise/xemacs-chise.git] / src / emacs.c
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, 2002 Ben Wing.
6    Copyright (C) 2000,2002,2005,2006 MORIOKA Tomohiko.
7
8 This file is part of XEmacs.
9
10 XEmacs is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
13 later version.
14
15 XEmacs is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with XEmacs; see the file COPYING.  If not, write to
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA.  */
24
25 /* Synched up with: Mule 2.0, FSF 19.28. */
26
27 /* Capsule summary of the various releases of Lucid Emacs/XEmacs and
28    FSF/GNU Emacs.  Provided here for use in cross-referencing version
29    releases and dates in comments, esp. in the authorship comments at
30    the beginning of each file.  More information about history can be
31    found in the beginning of the Internals Manual and in the About page.
32
33
34 -- A time line for Lucid Emacs/XEmacs is
35
36 version 19.0 shipped with Energize 1.0, April 1992.
37 version 19.1 released June 4, 1992.
38 version 19.2 released June 19, 1992.
39 version 19.3 released September 9, 1992.
40 version 19.4 released January 21, 1993.
41 version 19.5 was a repackaging of 19.4 with a few bug fixes and
42   shipped with Energize 2.0.  Never released to the net.
43 version 19.6 released April 9, 1993.
44 version 19.7 was a repackaging of 19.6 with a few bug fixes and
45   shipped with Energize 2.1.  Never released to the net.
46 version 19.8 released September 6, 1993.
47 version 19.9 released January 12, 1994.
48 version 19.10 released May 27, 1994.
49 version 19.11 (first XEmacs) released September 13, 1994.
50 version 19.12 released June 23, 1995.
51 version 19.13 released September 1, 1995.
52 version 19.14 released June 23, 1996.
53 version 20.0 released February 9, 1997.
54 version 19.15 released March 28, 1997.
55 version 20.1 (not released to the net) April 15, 1997.
56 version 20.2 released May 16, 1997.
57 version 19.16 released October 31, 1997.
58 version 20.3 (the first stable version of XEmacs 20.x) released
59   November 30, 1997.
60 version 20.4 released February 28, 1998.
61
62
63 -- A time line for GNU Emacs version 19 is
64
65 version 19.7 (beta) (first beta release) released ??????; prob. late May 1993.
66 version 19.8 (beta) released May 27, 1993.
67 version 19.9 (beta) released May 27, 1993.
68 version 19.10 (beta) released May 30, 1993.
69 version 19.11 (beta) released June 1, 1993.
70 version 19.12 (beta) released June 2, 1993.
71 version 19.13 (beta) released June 8, 1993.
72 version 19.14 (beta) released June 17, 1993.
73 version 19.15 (beta) released June 19, 1993.
74 version 19.16 (beta) released July 6, 1993.
75 version 19.17 (beta) released late July, 1993.
76 version 19.18 (beta) released August 9, 1993.
77 version 19.19 (beta) released August 15, 1993.
78 version 19.20 (beta) released November 17, 1993.
79 version 19.21 (beta) released November 17, 1993.
80 version 19.22 (beta) released November 28, 1993.
81 version 19.23 (beta) released May 17, 1994.
82 version 19.24 (beta) released May 16, 1994.
83 version 19.25 (beta) released June 3, 1994.
84 version 19.26 (beta) released September 11, 1994.
85 version 19.27 (beta) released September 14, 1994.
86 version 19.28 (first ``official'' release) released November 1, 1994.
87 version 19.29 released June 21, 1995.
88 version 19.30 released November 24, 1995.
89 version 19.31 released May 25, 1996.
90 version 19.32 released July 31, 1996.
91 version 19.33 released August 11, 1996.
92 version 19.34 released August 21, 1996.
93 version 19.34b released September 6, 1996.
94
95
96 -- A time line for GNU Emacs version 20 is
97
98 version 20.1 released September 17, 1997.
99 version 20.2 released September 20, 1997.
100 version 20.3 released August 19, 1998.
101
102
103 -- A time line for GNU Emacs version 18 and older is
104
105 GNU Emacs version 15 (15.34) was released sometime in 1984 or 1985 and
106   shared some code with a version of Emacs written by James Gosling (the
107   same James Gosling who later created the Java language).
108 GNU Emacs version 16 (first released version was 16.56) was released on
109   July 15, 1985.  All Gosling code was removed due to potential copyright
110   problems with the code.
111 version 16.57: released on September 16, 1985.
112 versions 16.58, 16.59: released on September 17, 1985.
113 version 16.60: released on September 19, 1985.  These later version 16's
114   incorporated patches from the net, esp. for getting Emacs to work under
115   System V.
116 version 17.36 (first official v17 release) released on December 20, 1985.
117   Included a TeX-able user manual.  First official unpatched version that
118    worked on vanilla System V machines.
119 version 17.43 (second official v17 release) released on January 25, 1986.
120 version 17.45 released on January 30, 1986.
121 version 17.46 released on February 4, 1986.
122 version 17.48 released on February 10, 1986.
123 version 17.49 released on February 12, 1986.
124 version 17.55 released on March 18, 1986.
125 version 17.57 released on March 27, 1986.
126 version 17.58 released on April 4, 1986.
127 version 17.61 released on April 12, 1986.
128 version 17.63 released on May 7, 1986.
129 version 17.64 released on May 12, 1986.
130 version 18.24 (a beta version) released on October 2, 1986.
131 version 18.30 (a beta version) released on November 15, 1986.
132 version 18.31 (a beta version) released on November 23, 1986.
133 version 18.32 (a beta version) released on December 7, 1986.
134 version 18.33 (a beta version) released on December 12, 1986.
135 version 18.35 (a beta version) released on January 5, 1987.
136 version 18.36 (a beta version) released on January 21, 1987.
137 January 27, 1987: The Great Usenet Renaming.  net.emacs is now comp.emacs.
138 version 18.37 (a beta version) released on February 12, 1987.
139 version 18.38 (a beta version) released on March 3, 1987.
140 version 18.39 (a beta version) released on March 14, 1987.
141 version 18.40 (a beta version) released on March 18, 1987.
142 version 18.41 (the first ``official'' release) released on March 22, 1987.
143 version 18.45 released on June 2, 1987.
144 version 18.46 released on June 9, 1987.
145 version 18.47 released on June 18, 1987.
146 version 18.48 released on September 3, 1987.
147 version 18.49 released on September 18, 1987.
148 version 18.50 released on February 13, 1988.
149 version 18.51 released on May 7, 1988.
150 version 18.52 released on September 1, 1988.
151 version 18.53 released on February 24, 1989.
152 version 18.54 released on April 26, 1989.
153 version 18.55 released on August 23, 1989.  This is the earliest version
154   that is still available by FTP.
155 version 18.56 released on January 17, 1991.
156 version 18.57 released late January, 1991.
157 version 18.58 released ?????.
158 version 18.59 released October 31, 1992.
159
160 */
161
162 /* Note: It is necessary to specify <config.h> and not "config.h" in
163    order for the --srcdir type of compilation to work properly.
164    Otherwise the config.h from the srcdir, rather than the one from
165    the build dir, will be used. */
166
167 #include <config.h>
168 #include "lisp.h"
169
170 #include "backtrace.h" /* run-emacs-from-temacs needs this */
171 #include "buffer.h"
172 #include "commands.h"
173 #include "console.h"
174 #include "process.h"
175 #include "redisplay.h"
176 #include "frame.h"
177 #include "sysdep.h"
178
179 #include "syssignal.h" /* Always include before systty.h */
180 #include "systty.h"
181 #include "sysfile.h"
182 #include "systime.h"
183
184 #ifdef CYGWIN
185 #include "syswindows.h"
186 #endif
187
188 #ifdef PDUMP
189 #include "dumper.h"
190 #endif
191
192 #ifndef SEPCHAR
193 #define SEPCHAR ':'
194 #endif
195
196 #ifdef QUANTIFY
197 #include <quantify.h>
198 #endif
199
200 #ifdef HAVE_SHLIB
201 #include "sysdll.h"
202 #endif
203
204 #if defined (HAVE_LOCALE_H) && \
205    (defined (I18N2) || defined (I18N3) || defined (I18N4))
206 #include <locale.h>
207 #endif
208
209 #ifdef TOOLTALK
210 #include TT_C_H_FILE
211 #endif
212
213 #if defined (WIN32_NATIVE)
214 #include "nt.h"
215 #endif
216
217 /* For PATH_EXEC */
218 #include <paths.h>
219
220 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
221 void report_sheap_usage (int die_if_pure_storage_exceeded);
222 #endif
223
224 #if !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC)
225 extern void *(*__malloc_hook)(size_t);
226 extern void *(*__realloc_hook)(void *, size_t);
227 extern void (*__free_hook)(void *);
228 #endif  /* not SYSTEM_MALLOC && not DOUG_LEA_MALLOC */
229
230 /* Command line args from shell, as list of strings */
231 Lisp_Object Vcommand_line_args;
232
233 /* Set nonzero after XEmacs has started up the first time.
234   Prevents reinitialization of the Lisp world and keymaps
235   on subsequent starts.  */
236 int initialized;
237
238 #ifdef DOUG_LEA_MALLOC
239 # include <malloc.h>
240 /* Preserves a pointer to the memory allocated that copies that
241    static data inside glibc's malloc.  */
242 static void *malloc_state_ptr;
243 #endif /* DOUG_LEA_MALLOC */
244
245 # ifdef REL_ALLOC
246 void r_alloc_reinit (void);
247 # endif
248
249 #ifdef HAVE_GTK
250 void console_type_create_select_gtk(void);
251 #endif
252
253 /* Variable whose value is symbol giving operating system type. */
254 Lisp_Object Vsystem_type;
255
256 /* Variable whose value is string giving configuration built for.  */
257 Lisp_Object Vsystem_configuration;
258
259 /* Variable whose value is string containing the configuration options
260    XEmacs was built with.  */
261 Lisp_Object Vsystem_configuration_options;
262
263 /* Version numbers and strings */
264 Lisp_Object Vemacs_major_version;
265 Lisp_Object Vemacs_minor_version;
266 Lisp_Object Vemacs_patch_level;
267 Lisp_Object Vemacs_beta_version;
268 Lisp_Object Vxemacs_codename;
269 #ifdef INFODOCK
270 Lisp_Object Vinfodock_major_version;
271 Lisp_Object Vinfodock_minor_version;
272 Lisp_Object Vinfodock_build_version;
273 #endif
274
275 /* The path under which XEmacs was invoked. */
276 Lisp_Object Vinvocation_path;
277
278 /* The name under which XEmacs was invoked, with any leading directory
279    names discarded.  */
280 Lisp_Object Vinvocation_name;
281
282 /* The directory name from which XEmacs was invoked.  */
283 Lisp_Object Vinvocation_directory;
284
285 #if 0 /* FSFmacs */
286 /* The directory name in which to find subdirs such as lisp and etc.
287    nil means get them only from PATH_LOADSEARCH.  */
288 Lisp_Object Vinstallation_directory;
289 #endif
290
291 Lisp_Object Vemacs_program_name, Vemacs_program_version;
292 Lisp_Object Vexec_path;
293 Lisp_Object Vexec_directory, Vconfigure_exec_directory;
294 Lisp_Object Vlisp_directory, Vconfigure_lisp_directory;
295 Lisp_Object Vmule_lisp_directory, Vconfigure_mule_lisp_directory;
296 Lisp_Object Vutf_2000_lisp_directory, Vconfigure_utf_2000_lisp_directory;
297 Lisp_Object Vmodule_directory, Vconfigure_module_directory;
298 Lisp_Object Vsite_module_directory, Vconfigure_site_module_directory;
299 Lisp_Object Vconfigure_package_path;
300 Lisp_Object Vdata_directory, Vconfigure_data_directory;
301 Lisp_Object Vdoc_directory, Vconfigure_doc_directory;
302 Lisp_Object Vconfigure_lock_directory;
303 Lisp_Object Vdata_directory_list;
304 Lisp_Object Vconfigure_info_directory;
305 Lisp_Object Vsite_directory, Vconfigure_site_directory;
306 Lisp_Object Vconfigure_info_path;
307 Lisp_Object Vinternal_error_checking;
308 Lisp_Object Vmail_lock_methods, Vconfigure_mail_lock_method;
309 Lisp_Object Vpath_separator;
310
311 /* The default base directory XEmacs is installed under. */
312 Lisp_Object Vconfigure_exec_prefix_directory, Vconfigure_prefix_directory;
313
314 /* If nonzero, set XEmacs to run at this priority.  This is also used
315    in child_setup and sys_suspend to make sure subshells run at normal
316    priority. */
317 Fixnum emacs_priority;
318
319 /* Some FSF junk with running_asynch_code, to preserve the match
320    data.  Not necessary because we don't call process filters
321    asynchronously (i.e. from within QUIT). */
322 /* #### Delete this when merging the rest of my code */
323 int running_asynch_code;
324
325 /* If non-zero, a window-system was specified on the command line. */
326 int display_arg;
327
328 /* Type of display specified.  We cannot use a Lisp symbol here because
329    Lisp symbols may not initialized at the time that we set this
330    variable. */
331 const char *display_use;
332
333 /* If non-zero, then the early error handler will only print the error
334    message and exit. */
335 int suppress_early_error_handler_backtrace;
336
337 /* An address near the bottom of the stack.
338    Tells GC how to save a copy of the stack.  */
339 char *stack_bottom;
340
341 #ifdef USG_SHARED_LIBRARIES
342 /* If nonzero, this is the place to put the end of the writable segment
343    at startup.  */
344
345 uintptr_t bss_end = 0;
346 #endif
347
348 /* Number of bytes of writable memory we can expect to be able to get */
349 unsigned long lim_data;
350
351 /* WARNING!
352
353    Some LISP-visible command-line options are set by XEmacs _before_ the
354    data is dumped in building a --pdump XEmacs, but used _after_ it is
355    restored in normal operation.  Thus the dump-time values overwrite the
356    values XEmacs is getting at runtime.  Such variables must be saved
357    before loading the dumpfile, and restored afterward.
358
359    Therefore these variables may not be initialized in vars_of_emacs().
360
361    The save/restore is done immediately before and after pdump_load() in
362    main_1().  See that function for the current list of protected variables.
363
364    Note that saving/restoring is only necessary for a few variables that are
365      o command line arguments effective at runtime (as opposed to dump-time),
366      o parsed before pdump_load, and
367      o exported to Lisp via a DEFVAR.
368 */
369
370 /* Nonzero means running XEmacs without interactive terminal.  */
371
372 int noninteractive;
373
374 /* Value of Lisp variable `noninteractive'.
375    Normally same as C variable `noninteractive'
376    but nothing terrible happens if user sets this one.
377
378    Shadowed from the pdumper by `noninteractive'. */
379
380 int noninteractive1;
381
382 /* Nonzero means don't perform site-lisp searches at startup */
383 int inhibit_site_lisp;
384
385 /* Nonzero means don't perform site-modules searches at startup */
386 int inhibit_site_modules;
387
388 /* Nonzero means don't respect early packages at startup */
389 int inhibit_early_packages;
390
391 /* Nonzero means don't load package autoloads at startup */
392 int inhibit_autoloads;
393
394 /* Nonzero means don't load the dump file (ignored if not PDUMP)  */
395
396 int nodumpfile;
397
398 /* Nonzero means print debug information about path searching */
399 int debug_paths;
400
401 /* Save argv and argc.  */
402 static Extbyte **initial_argv;  /* #### currently unused */
403 static int initial_argc;        /* #### currently unused */
404
405 static void sort_args (int argc, char **argv);
406
407 Lisp_Object Qkill_emacs_hook;
408 Lisp_Object Qsave_buffers_kill_emacs;
409
410 extern Lisp_Object Vlisp_EXEC_SUFFIXES;
411
412 \f
413
414 /* Ben's capsule summary about expected and unexpected exits from XEmacs.
415
416    Expected exits occur when the user directs XEmacs to exit, for example
417    by pressing the close button on the only frame in XEmacs, or by typing
418    C-x C-c.  This runs `save-buffers-kill-emacs', which saves any necessary
419    buffers, and then exits using the primitive `kill-emacs'.
420
421    However, unexpected exits occur in a few different ways:
422
423      -- a memory access violation or other hardware-generated exception
424         occurs.  This is the worst possible problem to deal with, because
425         the fault can occur while XEmacs is in any state whatsoever, even
426         quite unstable ones.  As a result, we need to be *extremely* careful
427         what we do.
428      -- we are using one X display (or if we've used more, we've closed the
429         others already), and some hardware or other problem happens and
430         suddenly we've lost our connection to the display.  In this situation,
431         things are not so dire as in the last one; our code itself isn't
432         trashed, so we can continue execution as normal, after having set
433         things up so that we can exit at the appropriate time.  Our exit
434         still needs to be of the emergency nature; we have no displays, so
435         any attempts to use them will fail.  We simply want to auto-save
436         (the single most important thing to do during shut-down), do minimal
437         cleanup of stuff that has an independent existence outside of XEmacs,
438         and exit.
439
440         Currently, both unexpected exit scenarios described above set
441         preparing_for_armageddon to indicate that nonessential and possibly
442         dangerous things should not be done, specifically:
443
444         -- no garbage collection.
445         -- no hooks are run.
446         -- no messages of any sort from autosaving.
447         -- autosaving tries harder, ignoring certain failures.
448         -- existing frames are not deleted.
449
450         (Also, all places that set preparing_for_armageddon also
451         set dont_check_for_quit.  This happens separately because it's
452         also necessary to set other variables to make absolutely sure
453         no quitting happens.)
454
455         In the first scenario above (the access violation), we also set
456         fatal_error_in_progress.  This causes more things to not happen:
457
458         -- assertion failures do not abort.
459         -- printing code does not do code conversion or gettext when
460            printing to stdout/stderr.
461 */
462
463 /* Nonzero if handling a fatal error already. */
464 int fatal_error_in_progress;
465
466 /* Non-nil means we're going down, so we better not run any hooks
467    or do other non-essential stuff. */
468 int preparing_for_armageddon;
469
470 /* Nonzero means we're in an unstable situation and need to skip
471    i18n conversions and such during printing. */
472 int inhibit_non_essential_printing_operations;
473
474 static JMP_BUF run_temacs_catch;
475
476 static int run_temacs_argc;
477 static char **run_temacs_argv;
478 static char *run_temacs_args;
479 static EMACS_INT run_temacs_argv_size;
480 static EMACS_INT run_temacs_args_size;
481
482 static void shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save);
483
484 /* ------------------------------- */
485 /*  low-level debugging functions  */
486 /* ------------------------------- */
487
488 #if defined (WIN32_NATIVE) && defined (DEBUG_XEMACS)
489 #define debugging_breakpoint() DebugBreak ()
490 #else
491 #define debugging_breakpoint()
492 #endif
493
494 void
495 debug_break (void)
496 {
497   debugging_breakpoint ();
498 }
499
500 #if defined (WIN32_NATIVE) || defined (CYGWIN)
501
502 /* Return whether all bytes in the specified memory block can be read. */
503 int
504 debug_can_access_memory (void *ptr, Bytecount len)
505 {
506   return !IsBadReadPtr (ptr, len);
507 }
508
509 #else /* !(defined (WIN32_NATIVE) || defined (CYGWIN)) */
510
511 /* #### There must be a better way!!!! */
512
513 static JMP_BUF memory_error_jump;
514
515 static SIGTYPE
516 debug_memory_error (int signum)
517 {
518   EMACS_REESTABLISH_SIGNAL (signum, debug_memory_error);
519   EMACS_UNBLOCK_SIGNAL (signum);
520   LONGJMP (memory_error_jump, 1);
521 }
522
523 /* Return whether all bytes in the specified memory block can be read. */
524 int
525 debug_can_access_memory (void *ptr, Bytecount len)
526 {
527   /* Use volatile to protect variables from being clobbered by longjmp. */
528   SIGTYPE (*volatile old_sigbus) (int);
529   SIGTYPE (*volatile old_sigsegv) (int);
530   volatile int old_errno = errno;
531   volatile int retval = 1;
532
533   if (!SETJMP (memory_error_jump))
534     {
535       old_sigbus =
536         (SIGTYPE (*) (int)) signal (SIGBUS, debug_memory_error);
537       old_sigsegv =
538         (SIGTYPE (*) (int)) signal (SIGSEGV, debug_memory_error);
539
540       if (len > 1)
541         /* If we can, try to avoid problems with super-optimizing compilers
542            that might decide that memcmp (ptr, ptr, len) can be optimized
543            away since its result is always 1. */
544         memcmp (ptr, (char *) ptr + 1, len - 1);
545       else
546         memcmp (ptr, ptr, len);
547     }
548   else
549     retval = 0;
550   signal (SIGBUS, old_sigbus);
551   signal (SIGSEGV, old_sigsegv);
552   errno = old_errno;
553
554   return retval;
555 }
556
557 #endif /* defined (WIN32_NATIVE) || defined (CYGWIN) */
558
559 #ifdef DEBUG_XEMACS
560
561 DEFUN ("force-debugging-signal", Fforce_debugging_signal, 0, 1, 0, /*
562 Cause XEmacs to enter the debugger.
563 On some systems, there may be no way to do this gracefully; if so,
564 nothing happens unless ABORT is non-nil, in which case XEmacs will
565 ABORT() -- a sure-fire way to immediately get back to the debugger,
566 but also a sure-fire way to kill XEmacs (and dump core on Unix
567 systems)!
568 */
569        (abort_))
570 {
571   debugging_breakpoint ();
572   if (!NILP (abort_))
573     ABORT ();
574   return Qnil;
575 }
576
577 #endif /* DEBUG_XEMACS */
578
579 static void
580 ensure_no_quitting_from_now_on (void)
581 {
582   /* make sure no quitting from now on!! */
583   dont_check_for_quit = 1;
584   Vinhibit_quit = Qt;
585   Vquit_flag = Qnil;
586 }
587
588 /* Handle bus errors, illegal instruction, etc. */
589 SIGTYPE
590 fatal_error_signal (int sig)
591 {
592   fatal_error_in_progress++;
593   inhibit_non_essential_printing_operations = 1;
594   preparing_for_armageddon = 1;
595
596   ensure_no_quitting_from_now_on ();
597
598   /* Unblock the signal so that if the same signal gets sent in the
599      code below, we avoid a deadlock. */
600   EMACS_UNBLOCK_SIGNAL (sig);
601
602   /* Only try auto-saving first time through.  If we crash in auto-saving,
603      don't do it again. */
604   if (fatal_error_in_progress == 1)
605     {
606       Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
607       /* Do this so that the variable has the same value of 2 regardless of
608          whether we made it through auto-saving correctly. */
609       fatal_error_in_progress++;
610     }
611   else if (fatal_error_in_progress == 2)
612     stderr_out ("WARNING: Unable to auto-save your files properly.\n"
613                 "Some or all may in fact have been auto-saved.\n"
614                 "\n");
615
616   /* Now, reset our signal handler, so the next time, we just die.
617      Don't do this before auto-saving. */
618   signal (sig, SIG_DFL);
619
620   /* Keep in mind that there's more than one signal that we can crash
621      on. */
622   /* If fatal error occurs in code below, avoid infinite recursion.  */
623   if (fatal_error_in_progress <= 2)
624     {
625       shut_down_emacs (sig, Qnil, 1);
626       stderr_out ("\nLisp backtrace follows:\n\n");
627       Fbacktrace (Qexternal_debugging_output, Qt);
628 # if 0  /* This is evil, rarely useful, and causes grief in some cases. */
629       /* Check for Sun-style stack printing via /proc */
630       {
631         const char *pstack = "/usr/proc/bin/pstack";
632         if (access (pstack, X_OK) == 0)
633           {
634             char buf[100];
635             stderr_out ("\nC backtrace follows:\n"
636                        "(A real debugger may provide better information)\n\n");
637             sprintf (buf, "%s %d >&2", pstack, (int)getpid());
638             system (buf);
639           }
640       }
641 # endif
642     }
643   /* Signal the same code; this time it will really be fatal. */
644   kill (getpid (), sig);
645   SIGRETURN;
646 }
647
648 #ifdef _MSC_VER
649
650 static DWORD
651 mswindows_handle_hardware_exceptions (DWORD code)
652 {
653   if (code != STATUS_ACCESS_VIOLATION && code != STATUS_ILLEGAL_INSTRUCTION
654       && code != STATUS_PRIVILEGED_INSTRUCTION
655       && code != STATUS_DATATYPE_MISALIGNMENT)
656     return EXCEPTION_CONTINUE_SEARCH;
657
658   /* I don't know if this filter is still wrapped in the outer __try, but
659      it doesn't hurt to have another one. --ben
660      And it lets us control more exactly what we really want to do in such
661      a situation. */
662   __try
663     {
664       fatal_error_in_progress++;
665       inhibit_non_essential_printing_operations = 1;
666       preparing_for_armageddon = 1;
667
668       ensure_no_quitting_from_now_on ();
669
670       /* Only try auto-saving first time through.  If we crash in auto-saving,
671          don't do it again. */
672       if (fatal_error_in_progress == 1)
673         {
674           Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
675           /* Do this so that the variable has the same value of 2 regardless of
676              whether we made it through auto-saving correctly. */
677           fatal_error_in_progress++;
678         }
679       else if (fatal_error_in_progress == 2)
680         stderr_out ("WARNING: Unable to auto-save your files properly.\n"
681                     "Some or all may in fact have been auto-saved.\n"
682                     "\n");
683
684       /* If fatal error occurs in code below, avoid infinite recursion.  */
685       if (fatal_error_in_progress <= 2)
686         {
687           shut_down_emacs (-1, Qnil, 1);
688           stderr_out ("\nLisp backtrace follows:\n\n");
689           Fbacktrace (Qexternal_debugging_output, Qt);
690         }
691     }
692   /* VC++ documentation says that
693      GetExceptionCode() cannot be called inside the filter itself. */
694
695   /*  __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {}
696
697      The line above is original.  Unfortunately, when an error is tripped
698      inside of the handler (e.g. during Fbacktrace()), and the handler for
699      the handler is invoked, it correctly notices that something is amiss
700      and it should just return -- but it returns EXCEPTION_CONTINUE_SEARCH,
701      which causes the debugger to be invoked debugging the handler code in
702      this function -- and WITH THE STACK UNWOUND so that you see main()
703      calling mswindows_handle_hardware_exceptions(), calling Fbacktrace(),
704      and a crash a couple of frames in -- AND NO SIGN OF THE ORIGINAL CRASH!
705
706      There's some real weirdness going on in the stack handling -- unlike
707      in Unix, where further crashes just keep adding to the stack, it seems
708      that under the structured-exception-handling, the stack can actually
709      bounce back and forth between the full stack at the location of the
710      exception and the unwound stack at the place where the __try clause was
711      established.  I don't completely understand it.  What I do know is that
712      returning EXCEPTION_EXECUTE_HANDLER on nested crash has the effect of
713      aborting execution of the handler and going back to the outer filter
714      function, which returns EXCEPTION_CONTINUE_SEARCH and everything is
715      hunky-dorey -- your debugger sees a crash at the right location with
716      the right stack.
717
718      I'm leaving in the trickier Unix-like code in the handler; someone who
719      understands better than me how the stack works in these handlers could
720      fix it up more.  As it is, it works pretty well, so I'm not likely to
721      touch it more. --ben
722   */
723
724   __except (EXCEPTION_EXECUTE_HANDLER) {}
725
726
727   /* pretend we didn't handle this, so that the debugger is invoked and/or
728      the normal GPF box appears. */
729   return EXCEPTION_CONTINUE_SEARCH;
730 }
731
732 #endif /* _MSC_VER */
733
734 \f
735
736 #ifdef SIGDANGER
737
738 /* Handler for SIGDANGER.  */
739 SIGTYPE
740 memory_warning_signal (int sig)
741 {
742   /* #### bad bad bad; this function shouldn't do anything except
743      set a flag, or weird corruption could happen. */
744   signal (sig, memory_warning_signal);
745
746   malloc_warning
747     (GETTEXT ("Operating system warns that virtual memory is running low.\n"));
748
749   /* It might be unsafe to call do_auto_save now.  */
750   force_auto_save_soon ();
751 }
752 #endif /* SIGDANGER */
753 \f
754 /* Code for dealing with Lisp access to the Unix command line */
755
756 static Lisp_Object
757 make_arg_list_1 (int argc, Extbyte **argv, int skip_args)
758 {
759   Lisp_Object result = Qnil;
760   REGISTER int i;
761
762   for (i = argc - 1; i >= 0; i--)
763     {
764       if (i == 0 || i > skip_args)
765         {
766 #ifdef WIN32_NATIVE
767           if (i == 0)
768             {
769               /* Do not trust to what crt0 has stuffed into argv[0] */
770               char full_exe_path[MAX_PATH];
771               Lisp_Object fullpath;
772
773               GetModuleFileName (NULL, full_exe_path, MAX_PATH);
774               fullpath = build_ext_string (full_exe_path, Qmswindows_tstr);
775               result = Fcons (fullpath, result);
776 #if defined(HAVE_SHLIB)
777               {
778                 Extbyte *fullpathext;
779
780                 LISP_STRING_TO_EXTERNAL (fullpath, fullpathext,
781                                   Qdll_filename_encoding);
782                 (void) dll_init (fullpathext);
783               }
784 #endif
785             }
786           else
787 #endif
788             result = Fcons (build_ext_string (argv[i],
789                                               Qcommand_argument_encoding),
790                             result);
791         }
792     }
793   return result;
794 }
795
796 Lisp_Object
797 make_arg_list (int argc, Extbyte **argv)
798 {
799   return make_arg_list_1 (argc, argv, 0);
800 }
801
802 /* Calling functions are also responsible for calling free_argc_argv
803    when they are done with the generated list. */
804 void
805 make_argc_argv (Lisp_Object argv_list, int *argc, Extbyte ***argv)
806 {
807   Lisp_Object next;
808   int n = XINT (Flength (argv_list));
809   REGISTER int i;
810   *argv = (Extbyte**) xmalloc ((n+1) * sizeof (Extbyte*));
811
812   for (i = 0, next = argv_list; i < n; i++, next = XCDR (next))
813     {
814       const Extbyte *temp;
815       CHECK_STRING (XCAR (next));
816
817       LISP_STRING_TO_EXTERNAL (XCAR (next), temp, Qcommand_argument_encoding);
818       (*argv) [i] = xstrdup (temp);
819     }
820   (*argv) [n] = 0;
821   *argc = i;
822 }
823
824 void
825 free_argc_argv (Extbyte **argv)
826 {
827   int elt = 0;
828
829   while (argv[elt])
830     {
831       xfree (argv[elt]);
832       elt++;
833     }
834   xfree (argv);
835 }
836
837 static void
838 init_cmdargs (int argc, Extbyte **argv, int skip_args)
839 {
840   initial_argv = argv;
841   initial_argc = argc;
842
843   Vcommand_line_args = make_arg_list_1 (argc, argv, skip_args);
844 }
845
846 DEFUN ("invocation-name", Finvocation_name, 0, 0, 0, /*
847 Return the program name that was used to run XEmacs.
848 Any directory names are omitted.
849 */
850        ())
851 {
852   return Fcopy_sequence (Vinvocation_name);
853 }
854
855 DEFUN ("invocation-directory", Finvocation_directory, 0, 0, 0, /*
856 Return the directory name in which the Emacs executable was located.
857 */
858        ())
859 {
860   return Fcopy_sequence (Vinvocation_directory);
861 }
862
863 \f
864 #ifdef I18N4
865                                 /* #### - don't know why I18N4 on SunOS/JLE
866                                    can't deal with this.  It's a potential
867                                    bug that needs to be looked at. */
868 # undef RUN_TIME_REMAP
869 #endif
870
871 /* Test whether the next argument in ARGV matches SSTR or a prefix of
872    LSTR (at least MINLEN characters).  If so, then if VALPTR is non-null
873    (the argument is supposed to have a value) store in *VALPTR either
874    the next argument or the portion of this one after the equal sign.
875    ARGV is read starting at position *SKIPPTR; this index is advanced
876    by the number of arguments used.
877
878    Too bad we can't just use getopt for all of this, but we don't have
879    enough information to do it right.  */
880
881 static int
882 argmatch (char **argv, int argc, char *sstr, char *lstr,
883           int minlen, char **valptr, int *skipptr)
884 {
885   char *p = NULL;
886   int arglen;
887   char *arg;
888
889   /* Don't access argv[argc]; give up in advance.  */
890   if (argc <= *skipptr + 1)
891     return 0;
892
893   arg = argv[*skipptr+1];
894   if (arg == NULL)
895     return 0;
896   if (strcmp (arg, sstr) == 0)
897     {
898       if (valptr != NULL)
899         {
900           *valptr = argv[*skipptr+2];
901           *skipptr += 2;
902         }
903       else
904         *skipptr += 1;
905       return 1;
906     }
907   arglen = (valptr != NULL && (p = strchr (arg, '=')) != NULL
908             ? p - arg : (int) strlen (arg));
909   if (lstr == 0 || arglen < minlen || strncmp (arg, lstr, arglen) != 0)
910     return 0;
911   else if (valptr == NULL)
912     {
913       *skipptr += 1;
914       return 1;
915     }
916   else if (p != NULL)
917     {
918       *valptr = p+1;
919       *skipptr += 1;
920       return 1;
921     }
922   else if (argv[*skipptr+2] != NULL)
923     {
924       *valptr = argv[*skipptr+2];
925       *skipptr += 2;
926       return 1;
927     }
928   else
929     {
930       return 0;
931     }
932 }
933
934 /* Make stack traces always identify version + configuration */
935 #define main_1 STACK_TRACE_EYE_CATCHER
936
937 /* This function is not static, so that the compiler is less likely to
938    inline it, which would make it not show up in stack traces.
939
940    The restart argument is a flag that indicates that main_1 is now
941    being called for the second time in this invocation of xemacs; this can
942    only happen in an xemacs that is not loaded with dumped data (temacs
943    with the conventional dumper or xemacs -nd with the pdumper).   See
944    Frun_emacs_from_temacs().
945
946    restart interacts with initialized as follows (per Olivier Galibert):
947
948      It's perverted.
949
950      initialized==0 => temacs
951      initialized!=0 && restart!=0 => run-temacs
952      initialized!=0 && restart==0 => xemacs/post pdump_load()
953 */
954 DECLARE_DOESNT_RETURN (main_1 (int, char **, char **, int));
955 DOESNT_RETURN
956 main_1 (int argc, char **argv, char **envp, int restart)
957 {
958   char stack_bottom_variable;
959   int skip_args = 0;
960   Lisp_Object load_me;
961   int inhibit_window_system;
962 #ifdef NeXT
963   extern int malloc_cookie;
964 #endif
965
966 #if (!defined (SYSTEM_MALLOC) && !defined (HAVE_LIBMCHECK)      \
967      && !defined (DOUG_LEA_MALLOC))
968   /* Make sure that any libraries we link against haven't installed a
969      hook for a gmalloc of a potentially incompatible version. */
970   /* If we're using libmcheck, the hooks have already been initialized, */
971   /* don't touch them. -slb */
972   __malloc_hook = NULL;
973   __realloc_hook = NULL;
974   __free_hook = NULL;
975 #endif /* not SYSTEM_MALLOC or HAVE_LIBMCHECK or DOUG_LEA_MALLOC */
976
977   noninteractive = 0;
978   inhibit_non_essential_printing_operations = 1;
979
980 #ifdef NeXT
981   /* 19-Jun-1995 -baw
982    * NeXT secret magic, ripped from Emacs-for-NS by Carl Edman
983    * <cedman@princeton.edu>.  Note that even Carl doesn't know what this
984    * does; it was provided by NeXT, and it presumable makes NS's mallocator
985    * work with dumping.  But malloc_jumpstart() and malloc_freezedry() in
986    * unexnext.c are both completely undocumented, even in NS header files!
987    * But hey, it solves all NS related memory problems, so who's
988    * complaining? */
989   if (initialized && malloc_jumpstart (malloc_cookie) != 0)
990     stderr_out ("malloc jumpstart failed!\n");
991 #endif /* NeXT */
992
993   /*
994 #if defined (GNU_MALLOC) && \
995     defined (ERROR_CHECK_MALLOC) && \
996     !defined (HAVE_LIBMCHECK)
997   */
998 #if defined(LOSING_GCC_DESTRUCTOR_FREE_BUG)
999   /* Prior to XEmacs 21, this was `#if 0'ed out.  */
1000   /* I'm enabling this because it is the only reliable way I've found to */
1001   /* prevent a very annoying problem where GCC will attempt to free(3) */
1002   /* memory at exit() and cause a coredump. */
1003   init_free_hook ();
1004 #endif
1005
1006   sort_args (argc, argv);
1007
1008 #if defined (WIN32_NATIVE) || defined (_SCO_DS)
1009   environ = envp;
1010 #endif
1011
1012   /* Record (approximately) where the stack begins.  */
1013   stack_bottom = &stack_bottom_variable;
1014
1015 #ifdef USG_SHARED_LIBRARIES
1016   if (bss_end)
1017     brk ((void *) bss_end);
1018 #endif
1019
1020   clearerr (stdin);
1021
1022 #if defined (HAVE_MMAP) && defined (REL_ALLOC)
1023   /* ralloc can only be used if using the GNU memory allocator. */
1024   init_ralloc ();
1025 #elif defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
1026   if (initialized)
1027     init_ralloc();
1028 #endif
1029
1030 #ifdef HAVE_SOCKS
1031   if (initialized)
1032     SOCKSinit (argv[0]);
1033 #endif /* HAVE_SOCKS */
1034
1035 #ifndef SYSTEM_MALLOC
1036   if (!initialized)
1037     /* Arrange to get warning messages as memory fills up.  */
1038     memory_warnings (0, malloc_warning);
1039 #endif  /* not SYSTEM_MALLOC */
1040
1041 #ifdef SET_EMACS_PRIORITY
1042   if (emacs_priority != 0)
1043     nice (-emacs_priority);
1044   setuid (getuid ());
1045 #endif /* SET_EMACS_PRIORITY */
1046
1047 #ifdef EXTRA_INITIALIZE
1048   EXTRA_INITIALIZE;
1049 #endif
1050
1051 #ifdef HAVE_WINDOW_SYSTEM
1052   inhibit_window_system = 0;
1053 #else
1054   inhibit_window_system = 1;
1055 #endif
1056
1057   /* Handle the -sd/--show-dump-id switch, which means show the hex dump_id and quit */
1058   if (argmatch (argv, argc, "-sd", "--show-dump-id", 9, NULL, &skip_args))
1059     {
1060 #ifdef PDUMP
1061       printf ("%08x\n", dump_id);
1062 #else
1063       printf ("Portable dumper not configured; -sd just forces exit.\n");
1064 #endif
1065       exit (0);
1066     }
1067
1068   /* Handle the -t switch, which specifies filename to use as terminal */
1069   {
1070     char *term;
1071     if (argmatch (argv, argc, "-t", "--terminal", 4, &term, &skip_args))
1072       {
1073         close (0);
1074         close (1);
1075         if (open (term, O_RDWR | OPEN_BINARY, 2) < 0)
1076           fatal ("%s: %s", term, strerror (errno));
1077         dup (0);
1078         if (! isatty (0))
1079           fatal ("%s: not a tty", term);
1080
1081 #if 0
1082         stderr_out ("Using %s", ttyname (0));
1083 #endif
1084         stderr_out ("Using %s", term);
1085         inhibit_window_system = 1;      /* -t => -nw */
1086       }
1087   }
1088
1089   /* Handle the --no-dump-file/-nd switch, which means don't load the dump file (ignored when not using pdump) */
1090   if (argmatch (argv, argc, "-nd", "--no-dump-file", 7, NULL, &skip_args))
1091     {
1092       nodumpfile = 1;
1093     }
1094
1095   /* Handle -nw switch */
1096   if (argmatch (argv, argc, "-nw", "--no-windows", 6, NULL, &skip_args))
1097     inhibit_window_system = 1;
1098
1099   /* Handle the -batch switch, which means don't do interactive display.  */
1100   if (argmatch (argv, argc, "-batch", "--batch", 5, NULL, &skip_args))
1101     {
1102 #if 0 /* I don't think this is correct. */
1103       inhibit_autoloads = 1;
1104 #endif
1105       noninteractive = 1;
1106     }
1107
1108   if (argmatch (argv, argc, "-debug-paths", "--debug-paths",
1109                 11, NULL, &skip_args))
1110       debug_paths = 1;
1111
1112   /* Partially handle -no-autoloads, -no-early-packages and -vanilla.  Packages */
1113   /* are searched prior to the rest of the command line being parsed in */
1114   /* startup.el */
1115   if (argmatch (argv, argc, "-no-early-packages", "--no-early-packages",
1116                 6, NULL, &skip_args))
1117     {
1118       inhibit_early_packages = 1;
1119       skip_args--;
1120     }
1121 #ifdef HAVE_SHLIB
1122   if (argmatch (argv, argc, "-no-site-modules", "--no-site-modules",
1123                 9, NULL, &skip_args))
1124     {
1125       inhibit_site_modules = 1;
1126       skip_args--;
1127     }
1128 #else
1129   inhibit_site_modules = 1;
1130 #endif
1131   if (argmatch (argv, argc, "-vanilla", "--vanilla",
1132                 7, NULL, &skip_args))
1133     {
1134       inhibit_early_packages = 1;
1135       skip_args--;
1136     }
1137
1138   if (argmatch (argv, argc, "-no-autoloads", "--no-autoloads",
1139                 7, NULL, &skip_args))
1140     {
1141       /* Inhibit everything */
1142       inhibit_autoloads = 1;
1143       skip_args--;
1144     }
1145
1146   if (argmatch (argv, argc, "-debug-paths", "--debug-paths",
1147                 6, NULL, &skip_args))
1148     {
1149       debug_paths = 1;
1150       skip_args--;
1151     }
1152
1153
1154   /* Partially handle the -version and -help switches: they imply -batch,
1155      but are not removed from the list. */
1156   if (argmatch (argv, argc, "-help", "--help",   3, NULL, &skip_args))
1157     noninteractive = 1, skip_args--;
1158
1159   if (argmatch (argv, argc, "-version", "--version", 3, NULL, &skip_args) ||
1160       argmatch (argv, argc, "-V",    0,              2, NULL, &skip_args))
1161       noninteractive = 1, skip_args--;
1162
1163   /* Now, figure out which type of console is our first console. */
1164
1165   display_arg = 0;
1166
1167   if (noninteractive)
1168     display_use = "stream";
1169   else
1170     display_use = "tty";
1171
1172 #ifndef HAVE_TTY
1173   if (inhibit_window_system)
1174     fatal ("Sorry, this XEmacs was not compiled with TTY support");
1175 #endif
1176
1177 #ifdef HAVE_WINDOW_SYSTEM
1178   /* Stupid kludge to catch command-line display spec.  We can't
1179      handle this argument entirely in window-system-dependent code
1180      because we don't even know which window-system-dependent code
1181      to run until we've recognized this argument.  */
1182   if (!inhibit_window_system && !noninteractive)
1183     {
1184 #ifdef HAVE_X_WINDOWS
1185       char *dpy = 0;
1186       int count_before = skip_args;
1187
1188       if (argmatch (argv, argc, "-d", "--display", 3, &dpy, &skip_args) ||
1189           argmatch (argv, argc, "-display", 0,     3, &dpy, &skip_args))
1190         {
1191           display_arg = 1;
1192           display_use = "x";
1193         }
1194       /* If we have the form --display=NAME,
1195          convert it into  -d name.
1196          This requires inserting a new element into argv.  */
1197       if (dpy != 0 && skip_args - count_before == 1)
1198         {
1199           char **new = (char **) xmalloc (sizeof (char *) * (argc + 2));
1200           int j;
1201
1202           for (j = 0; j < count_before + 1; j++)
1203             new[j] = argv[j];
1204           new[count_before + 1] = "-d";
1205           new[count_before + 2] = dpy;
1206           for (j = count_before + 2; j <argc; j++)
1207             new[j + 1] = argv[j];
1208           argv = new;
1209           argc++;
1210         }
1211       /* Change --display to -d, when its arg is separate.  */
1212       else if (dpy != 0 && skip_args > count_before
1213                && argv[count_before + 1][1] == '-')
1214         argv[count_before + 1] = "-d";
1215
1216       /* Don't actually discard this arg.  */
1217       skip_args = count_before;
1218
1219       /* If there is a non-empty environment var DISPLAY, set
1220          `display_use', but not `display_arg', which is only to be set
1221          if the display was specified on the command line. */
1222       if ((dpy = getenv ("DISPLAY")) && dpy[0])
1223         display_use = "x";
1224
1225 #endif /* HAVE_X_WINDOWS */
1226 #ifdef HAVE_GTK
1227       {
1228         char *dpy = getenv ("DISPLAY");
1229         if (dpy && dpy[0])
1230           display_use = "gtk";
1231       }
1232 #endif
1233 #ifdef HAVE_MS_WINDOWS
1234       if (strcmp(display_use, "x") != 0)
1235         display_use = "mswindows";
1236 #endif /* HAVE_MS_WINDOWS */
1237     }
1238 #endif /* HAVE_WINDOW_SYSTEM */
1239
1240   noninteractive1 = noninteractive;
1241
1242   /****** Now initialize everything *******/
1243
1244   /* First, do really basic environment initialization -- catching signals
1245      and the like.  These functions have no dependence on any part of
1246      the Lisp engine and need to be done both at dump time and at run time. */
1247
1248   init_signals_very_early ();
1249   init_data_very_early (); /* Catch math errors. */
1250 #ifdef LISP_FLOAT_TYPE
1251   init_floatfns_very_early (); /* Catch floating-point math errors. */
1252 #endif
1253   init_process_times_very_early (); /* Initialize our process timers.
1254                                        As early as possible, of course,
1255                                        so we can be fairly accurate. */
1256   init_intl_very_early (); /* set up the locale and domain for gettext and
1257                               such. */
1258 #ifdef HAVE_MS_WINDOWS
1259   init_mswindows_very_early (); /* Some things - like dde need to be
1260                                    initialized early so that the
1261                                    client doesn't give up waiting.  */
1262 #endif
1263
1264   /* Now initialize the Lisp engine and the like.  Done only during
1265      dumping.  No dependence on anything that may be in the user's
1266      environment when the dumped XEmacs is run.
1267
1268      We try to do things in an order that minimizes the non-obvious
1269      dependencies between functions. */
1270
1271   /* purify_flag 1 is correct even if CANNOT_DUMP.
1272    * loadup.el will set to nil at end. */
1273
1274   purify_flag = 0;
1275 #ifdef PDUMP
1276   if (restart)
1277     initialized = 1;
1278   else if (nodumpfile) {
1279     initialized = 0;
1280     purify_flag = 1;
1281   } else {
1282
1283     /* Keep command options from getting stomped.
1284
1285        Some LISP-visible options are changed by XEmacs _after_ the data is
1286        dumped in building a --pdump XEmacs, but _before_ it is restored in
1287        normal operation.  Thus the restored values overwrite the values
1288        XEmacs is getting at run-time.  Such variables must be saved here,
1289        and restored after loading the dumped data.
1290
1291        Boy, this is ugly, but how else to do it?
1292     */
1293
1294     /* noninteractive1 is saved in noninteractive, which isn't LISP-visible */
1295     int inhibit_early_packages_save = inhibit_early_packages;
1296     int inhibit_autoloads_save      = inhibit_autoloads;
1297     int debug_paths_save            = debug_paths;
1298     /* #### Give inhibit-site-lisp a command switch?  If so, uncomment: */
1299     /* int inhibit_site_lisp_save      = inhibit_site_lisp; */
1300     int inhibit_site_modules_save   = inhibit_site_modules;
1301
1302     initialized = pdump_load (argv[0]);
1303
1304     /* Now unstomp everything */
1305     noninteractive1        = noninteractive;
1306     inhibit_early_packages = inhibit_early_packages_save;
1307     inhibit_autoloads      = inhibit_autoloads_save;
1308     debug_paths            = debug_paths_save;
1309     /* #### Give inhibit-site-lisp a command switch?  If so, uncomment: */
1310     /* inhibit_site_lisp      = inhibit_site_lisp_save; */
1311     inhibit_site_modules   = inhibit_site_modules_save;
1312
1313     if (initialized)
1314       run_temacs_argc = -1;
1315     else
1316       purify_flag = 1;
1317   }
1318 #else
1319   if (!initialized)
1320     purify_flag = 1;
1321 #endif
1322
1323   if (!initialized)
1324     {
1325       /* Initialize things so that new Lisp objects
1326          can be created and objects can be staticpro'd.
1327          Must be basically the very first thing done
1328          because pretty much all of the initialization
1329          routines below create new objects. */
1330       init_alloc_once_early ();
1331
1332       /* Initialize Qnil, Qt, Qunbound, and the
1333          obarray.  After this, symbols can be
1334          interned.  This depends on init_alloc_once_early(). */
1335       init_symbols_once_early ();
1336
1337       /* Declare the basic symbols pertaining to errors,
1338          So that DEFERROR*() can be called. */
1339       init_errors_once_early ();
1340
1341       /* Make sure that opaque pointers can be created. */
1342       init_opaque_once_early ();
1343
1344       /* Now declare all the symbols and define all the Lisp primitives.
1345
1346          The *only* thing that the syms_of_*() functions are allowed to do
1347          is call one of the following:
1348
1349          INIT_LRECORD_IMPLEMENTATION()
1350          defsymbol(), DEFSYMBOL(), or DEFSYMBOL_MULTIWORD_PREDICATE()
1351          defsubr() (i.e. DEFSUBR)
1352          deferror(), DEFERROR(), or DEFERROR_STANDARD()
1353          defkeyword() or DEFKEYWORD()
1354
1355          Order does not matter in these functions.
1356          */
1357
1358       syms_of_abbrev ();
1359       syms_of_alloc ();
1360       syms_of_buffer ();
1361       syms_of_bytecode ();
1362       syms_of_callint ();
1363       syms_of_callproc ();
1364       syms_of_casefiddle ();
1365       syms_of_casetab ();
1366       syms_of_chartab ();
1367       syms_of_cmdloop ();
1368       syms_of_cmds ();
1369       syms_of_console ();
1370       syms_of_data ();
1371 #ifdef DEBUG_XEMACS
1372       syms_of_debug ();
1373       syms_of_tests ();
1374 #endif /* DEBUG_XEMACS */
1375       syms_of_device ();
1376 #ifdef HAVE_DIALOGS
1377       syms_of_dialog ();
1378 #endif
1379       syms_of_dired ();
1380       syms_of_doc ();
1381       syms_of_editfns ();
1382       syms_of_elhash ();
1383       syms_of_emacs ();
1384       syms_of_eval ();
1385 #ifdef HAVE_X_WINDOWS
1386       syms_of_event_Xt ();
1387 #endif
1388 #ifdef HAVE_GTK
1389       syms_of_event_gtk ();
1390 #endif
1391 #ifdef HAVE_DRAGNDROP
1392       syms_of_dragdrop ();
1393 #endif
1394       syms_of_event_stream ();
1395       syms_of_events ();
1396       syms_of_extents ();
1397       syms_of_faces ();
1398       syms_of_fileio ();
1399 #ifdef CLASH_DETECTION
1400       syms_of_filelock ();
1401 #endif /* CLASH_DETECTION */
1402       syms_of_floatfns ();
1403       syms_of_fns ();
1404       syms_of_font_lock ();
1405       syms_of_frame ();
1406       syms_of_general ();
1407       syms_of_glyphs ();
1408       syms_of_glyphs_eimage ();
1409       syms_of_glyphs_widget ();
1410       syms_of_gui ();
1411       syms_of_gutter ();
1412       syms_of_indent ();
1413       syms_of_intl ();
1414       syms_of_keymap ();
1415       syms_of_lread ();
1416       syms_of_macros ();
1417       syms_of_marker ();
1418       syms_of_md5 ();
1419 #ifdef HAVE_DATABASE
1420       syms_of_database ();
1421 #endif
1422 #ifdef HAVE_MENUBARS
1423       syms_of_menubar ();
1424 #endif
1425       syms_of_minibuf ();
1426 #ifdef HAVE_SHLIB
1427       syms_of_module ();
1428 #endif
1429       syms_of_objects ();
1430       syms_of_print ();
1431 #if !defined (NO_SUBPROCESSES)
1432       syms_of_process ();
1433 #ifdef HAVE_WIN32_PROCESSES
1434       syms_of_process_nt ();
1435 #endif
1436 #endif
1437       syms_of_profile ();
1438 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
1439       syms_of_ralloc ();
1440 #endif /* HAVE_MMAP && REL_ALLOC */
1441       syms_of_rangetab ();
1442       syms_of_redisplay ();
1443       syms_of_search ();
1444       syms_of_select ();
1445       syms_of_signal ();
1446       syms_of_sound ();
1447       syms_of_specifier ();
1448       syms_of_symbols ();
1449       syms_of_syntax ();
1450 #ifdef HAVE_SCROLLBARS
1451       syms_of_scrollbar ();
1452 #endif
1453 #ifdef HAVE_TOOLBARS
1454       syms_of_toolbar ();
1455 #endif
1456       syms_of_undo ();
1457       syms_of_widget ();
1458       syms_of_window ();
1459
1460 #ifdef HAVE_TTY
1461       syms_of_console_tty ();
1462       syms_of_device_tty ();
1463       syms_of_objects_tty ();
1464 #endif
1465
1466 #ifdef HAVE_GTK
1467       syms_of_device_gtk ();
1468       syms_of_frame_gtk ();
1469       syms_of_glyphs_gtk ();
1470       syms_of_objects_gtk ();
1471       syms_of_ui_gtk ();
1472       syms_of_select_gtk ();
1473 #ifdef HAVE_DIALOGS
1474       syms_of_dialog_gtk ();
1475 #endif
1476 #ifdef HAVE_MENUBARS
1477       syms_of_menubar_gtk ();
1478 #endif
1479       syms_of_select_gtk ();
1480       
1481 #if defined (HAVE_MENUBARS) || defined(HAVE_SCROLLBARS) || defined(HAVE_DIALOGS) || defined(HAVE_TOOLBARS)
1482       syms_of_gui_gtk ();
1483 #endif
1484 #endif /* HAVE_GTK */
1485
1486 #ifdef HAVE_X_WINDOWS
1487 #ifdef HAVE_BALLOON_HELP
1488       syms_of_balloon_x ();
1489 #endif
1490       syms_of_device_x ();
1491 #ifdef HAVE_DIALOGS
1492       syms_of_dialog_x ();
1493 #endif
1494       syms_of_frame_x ();
1495       syms_of_glyphs_x ();
1496       syms_of_objects_x ();
1497 #ifdef HAVE_MENUBARS
1498       syms_of_menubar_x ();
1499 #endif
1500       syms_of_select_x ();
1501 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
1502       syms_of_gui_x ();
1503 #endif
1504 #ifdef HAVE_XIM
1505 #ifdef XIM_XLIB
1506       syms_of_input_method_xlib ();
1507 #endif
1508 #endif /* HAVE_XIM */
1509 #endif /* HAVE_X_WINDOWS */
1510
1511 #ifdef HAVE_MS_WINDOWS
1512       syms_of_console_mswindows ();
1513       syms_of_device_mswindows ();
1514       syms_of_dialog_mswindows ();
1515       syms_of_frame_mswindows ();
1516       syms_of_objects_mswindows ();
1517       syms_of_select_mswindows ();
1518       syms_of_glyphs_mswindows ();
1519       syms_of_gui_mswindows ();
1520 #ifdef HAVE_MENUBARS
1521       syms_of_menubar_mswindows ();
1522 #endif
1523 #ifdef HAVE_SCROLLBARS
1524       syms_of_scrollbar_mswindows ();
1525 #endif
1526 #endif  /* HAVE_MS_WINDOWS */
1527 #ifdef HAVE_MSW_C_DIRED
1528       syms_of_dired_mswindows ();
1529 #endif
1530 #ifdef WIN32_NATIVE
1531       syms_of_ntproc ();
1532 #endif
1533 #if defined (WIN32_NATIVE) || defined (CYGWIN)
1534       syms_of_win32 ();
1535 #endif
1536
1537 #ifdef MULE
1538       syms_of_mule ();
1539       syms_of_mule_ccl ();
1540       syms_of_mule_charset ();
1541 #endif
1542 #ifdef FILE_CODING
1543       syms_of_file_coding ();
1544 #endif
1545 #ifdef MULE
1546 #ifdef HAVE_WNN
1547       syms_of_mule_wnn ();
1548 #endif
1549 #ifdef HAVE_CANNA
1550       syms_of_mule_canna ();
1551 #endif /* HAVE_CANNA */
1552 #endif /* MULE */
1553
1554 #ifdef SYMS_SYSTEM
1555       SYMS_SYSTEM;
1556 #endif
1557
1558 #ifdef SYMS_MACHINE
1559       SYMS_MACHINE;
1560 #endif
1561
1562       /*
1563 #if defined (GNU_MALLOC) && \
1564     defined (ERROR_CHECK_MALLOC) && \
1565     !defined (HAVE_LIBMCHECK)
1566       */
1567       /* Prior to XEmacs 21, this was `#if 0'ed out. -slb */
1568 #if defined (LOSING_GCC_DESTRUCTOR_FREE_BUG)
1569       syms_of_free_hook ();
1570 #endif
1571
1572 #ifdef TOOLTALK
1573       syms_of_tooltalk ();
1574 #endif
1575
1576 #ifdef SUNPRO
1577       syms_of_sunpro ();
1578 #endif
1579
1580 #ifdef HAVE_LDAP
1581       syms_of_eldap ();
1582 #endif
1583
1584 #ifdef HAVE_GPM
1585       syms_of_gpmevent ();
1586 #endif
1587
1588 #ifdef HAVE_POSTGRESQL
1589       syms_of_postgresql ();
1590 #endif
1591
1592 #ifdef HAVE_CONCORD
1593       syms_of_concord ();
1594 #endif
1595
1596       /* Now create the subtypes for the types that have them.
1597          We do this before the vars_*() because more symbols
1598          may get initialized here. */
1599
1600       /* Now initialize the console types and associated symbols.
1601          Other than the first function below, the functions may
1602          make exactly the following function/macro calls:
1603
1604          INITIALIZE_CONSOLE_TYPE()
1605          CONSOLE_HAS_METHOD()
1606
1607          For any given console type, the former macro must be called
1608          before the any calls to the latter macro. */
1609
1610       console_type_create ();
1611
1612       console_type_create_stream ();
1613
1614 #ifdef HAVE_TTY
1615       console_type_create_tty ();
1616       console_type_create_device_tty ();
1617       console_type_create_frame_tty ();
1618       console_type_create_objects_tty ();
1619       console_type_create_redisplay_tty ();
1620 #endif
1621
1622 #ifdef HAVE_GTK
1623       console_type_create_gtk ();
1624       console_type_create_select_gtk ();
1625       console_type_create_device_gtk ();
1626       console_type_create_frame_gtk ();
1627       console_type_create_objects_gtk ();
1628       console_type_create_glyphs_gtk ();
1629       console_type_create_redisplay_gtk ();
1630 #ifdef HAVE_MENUBARS
1631       console_type_create_menubar_gtk ();
1632 #endif
1633 #ifdef HAVE_SCROLLBARS
1634       console_type_create_scrollbar_gtk ();
1635 #endif
1636 #ifdef HAVE_TOOLBARS
1637       console_type_create_toolbar_gtk ();
1638 #endif
1639 #ifdef HAVE_DIALOGS
1640       console_type_create_dialog_gtk ();
1641 #endif
1642 #endif /* HAVE_GTK */
1643
1644 #ifdef HAVE_X_WINDOWS
1645       console_type_create_x ();
1646       console_type_create_device_x ();
1647       console_type_create_frame_x ();
1648       console_type_create_glyphs_x ();
1649       console_type_create_select_x ();
1650 #ifdef HAVE_MENUBARS
1651       console_type_create_menubar_x ();
1652 #endif
1653       console_type_create_objects_x ();
1654       console_type_create_redisplay_x ();
1655 #ifdef HAVE_SCROLLBARS
1656       console_type_create_scrollbar_x ();
1657 #endif
1658 #ifdef HAVE_TOOLBARS
1659       console_type_create_toolbar_x ();
1660 #endif
1661 #ifdef HAVE_DIALOGS
1662       console_type_create_dialog_x ();
1663 #endif
1664 #endif /* HAVE_X_WINDOWS */
1665
1666 #ifdef HAVE_MS_WINDOWS
1667       console_type_create_mswindows ();
1668       console_type_create_device_mswindows ();
1669       console_type_create_frame_mswindows ();
1670       console_type_create_objects_mswindows ();
1671       console_type_create_redisplay_mswindows ();
1672       console_type_create_glyphs_mswindows ();
1673       console_type_create_select_mswindows ();
1674 # ifdef HAVE_SCROLLBARS
1675       console_type_create_scrollbar_mswindows ();
1676 # endif
1677 #ifdef HAVE_MENUBARS
1678       console_type_create_menubar_mswindows ();
1679 #endif
1680 #ifdef HAVE_TOOLBARS
1681       console_type_create_toolbar_mswindows ();
1682 #endif
1683 #ifdef HAVE_DIALOGS
1684       console_type_create_dialog_mswindows ();
1685 #endif
1686 #endif
1687
1688       /* Now initialize the specifier types and associated symbols.
1689          Other than the first function below, the functions may
1690          make exactly the following function/macro calls:
1691
1692          INITIALIZE_SPECIFIER_TYPE()
1693          SPECIFIER_HAS_METHOD()
1694
1695          For any given specifier type, the former macro must be called
1696          before the any calls to the latter macro. */
1697
1698       specifier_type_create ();
1699
1700       specifier_type_create_image ();
1701       specifier_type_create_gutter ();
1702       specifier_type_create_objects ();
1703 #ifdef HAVE_TOOLBARS
1704       specifier_type_create_toolbar ();
1705 #endif
1706
1707       /* Now initialize the structure types and associated symbols.
1708          Other than the first function below, the functions may
1709          make exactly the following function/macro calls:
1710
1711          define_structure_type()
1712          define_structure_type_keyword()
1713
1714          */
1715
1716       structure_type_create ();
1717
1718       structure_type_create_chartab ();
1719       structure_type_create_faces ();
1720       structure_type_create_rangetab ();
1721       structure_type_create_hash_table ();
1722 #ifdef HAVE_CONCORD
1723       structure_type_create_concord ();
1724 #endif
1725
1726       /* Now initialize the image instantiator formats and associated symbols.
1727          Other than the first function below, the functions may
1728          make exactly the following function/macro calls:
1729
1730          INITIALIZE_IMAGE_INSTANTIATOR_FORMAT()
1731          IIFORMAT_HAS_METHOD()
1732          IIFORMAT_VALID_KEYWORD()
1733
1734          For any given image instantiator format, the first macro must be
1735          called before the any calls to the other macros. */
1736
1737       image_instantiator_format_create ();
1738       image_instantiator_format_create_glyphs_eimage ();
1739       image_instantiator_format_create_glyphs_widget ();
1740 #ifdef HAVE_TTY
1741       image_instantiator_format_create_glyphs_tty ();
1742 #endif
1743 #ifdef HAVE_X_WINDOWS
1744       image_instantiator_format_create_glyphs_x ();
1745 #endif /* HAVE_X_WINDOWS */
1746 #ifdef HAVE_MS_WINDOWS
1747       image_instantiator_format_create_glyphs_mswindows ();
1748 #endif /* HAVE_MSWINDOWS_WINDOWS */
1749 #ifdef HAVE_GTK
1750       image_instantiator_format_create_glyphs_gtk ();
1751 #endif
1752
1753       /* Now initialize the lstream types and associated symbols.
1754          Other than the first function below, the functions may
1755          make exactly the following function/macro calls:
1756
1757          LSTREAM_HAS_METHOD()
1758
1759          */
1760
1761       lstream_type_create ();
1762 #ifdef FILE_CODING
1763       lstream_type_create_file_coding ();
1764 #endif
1765 #if defined (HAVE_MS_WINDOWS) && !defined(HAVE_MSG_SELECT)
1766       lstream_type_create_mswindows_selectable ();
1767 #endif
1768
1769       /* Initialize processes implementation.
1770          The functions may make exactly the following function/macro calls:
1771
1772          PROCESS_HAS_METHOD()
1773       */
1774 #ifdef HAVE_UNIX_PROCESSES
1775       process_type_create_unix ();
1776 #endif
1777 #ifdef HAVE_WIN32_PROCESSES
1778       process_type_create_nt ();
1779 #endif
1780
1781       /* Now initialize most variables.
1782
1783          These functions may do exactly the following:
1784
1785          DEFVAR_INT()
1786          DEFVAR_LISP()
1787          DEFVAR_BOOL()
1788          DEFER_GETTEXT()
1789          Dynarr_*()
1790          Blocktype_*()
1791          staticpro()
1792          Fprovide(symbol)
1793          intern()
1794          Fput()
1795          xmalloc()
1796          defsymbol(), if it's absolutely necessary and you're sure that
1797            the symbol isn't referenced anywhere else in the initialization
1798            code
1799          Fset() on a symbol that is unbound
1800          assigning a symbol or constant value to a variable
1801          using a global variable that has been initialized
1802            earlier on in the same function
1803
1804          Any of the object-creating functions in alloc.c: e.g.
1805
1806          make_pure_*()
1807          make_string()
1808          build_string()
1809          make_vector()
1810          make_int()
1811          make_extent()
1812          alloc_lcrecord()
1813          Fcons()
1814          listN()
1815          make_opaque_ptr()
1816
1817          perhaps a few others.
1818
1819          NB:  Initialization or assignment should not be done here to certain
1820            variables settable from the command line.  See the comment above
1821            the call to pdump_load() in main_1().  This caveat should only
1822            apply to vars_of_emacs().
1823        */
1824
1825       /* Now allow Fprovide() statements to be made. */
1826       init_provide_once ();
1827
1828       /* Do that before any specifier creation (esp. vars_of_glyphs()) */
1829       vars_of_specifier ();
1830
1831       vars_of_abbrev ();
1832       vars_of_alloc ();
1833       vars_of_buffer ();
1834       vars_of_bytecode ();
1835       vars_of_callint ();
1836       vars_of_callproc ();
1837       vars_of_chartab ();
1838       vars_of_cmdloop ();
1839       vars_of_cmds ();
1840       vars_of_console ();
1841       vars_of_data ();
1842 #ifdef DEBUG_XEMACS
1843       vars_of_debug ();
1844       vars_of_tests ();
1845 #endif
1846       vars_of_console_stream ();
1847       vars_of_device ();
1848 #ifdef HAVE_DIALOGS
1849       vars_of_dialog ();
1850 #endif
1851       vars_of_dired ();
1852       vars_of_doc ();
1853 #ifdef HAVE_DRAGNDROP
1854       vars_of_dragdrop ();
1855 #endif
1856       vars_of_editfns ();
1857       vars_of_elhash ();
1858       vars_of_emacs ();
1859       vars_of_eval ();
1860
1861 #ifdef HAVE_X_WINDOWS
1862       vars_of_event_Xt ();
1863 #endif
1864 #if defined(HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS))
1865       vars_of_event_tty ();
1866 #endif
1867 #ifdef HAVE_MS_WINDOWS
1868       vars_of_event_mswindows ();
1869 #endif
1870       vars_of_event_stream ();
1871
1872       vars_of_events ();
1873       vars_of_extents ();
1874       vars_of_faces ();
1875       vars_of_fileio ();
1876 #ifdef CLASH_DETECTION
1877       vars_of_filelock ();
1878 #endif
1879       vars_of_floatfns ();
1880       vars_of_font_lock ();
1881       vars_of_frame ();
1882       vars_of_glyphs ();
1883       vars_of_glyphs_eimage ();
1884       vars_of_glyphs_widget ();
1885       vars_of_gui ();
1886       vars_of_gutter ();
1887       vars_of_indent ();
1888       vars_of_insdel ();
1889       vars_of_intl ();
1890 #ifdef HAVE_XIM
1891 #ifdef XIM_MOTIF
1892       vars_of_input_method_motif ();
1893 #else /* XIM_XLIB */
1894       vars_of_input_method_xlib ();
1895 #endif
1896 #endif /* HAVE_XIM */
1897       vars_of_keymap ();
1898       vars_of_lread ();
1899       vars_of_lstream ();
1900       vars_of_macros ();
1901       vars_of_md5 ();
1902 #ifdef HAVE_DATABASE
1903       vars_of_database ();
1904 #endif
1905 #ifdef HAVE_MENUBARS
1906       vars_of_menubar ();
1907 #endif
1908       vars_of_minibuf ();
1909 #ifdef HAVE_SHLIB
1910       vars_of_module ();
1911 #endif
1912 #ifdef WIN32_NATIVE
1913       vars_of_nt ();
1914       vars_of_ntproc ();
1915 #endif
1916       vars_of_objects ();
1917       vars_of_print ();
1918
1919 #ifndef NO_SUBPROCESSES
1920       vars_of_process ();
1921 #ifdef HAVE_UNIX_PROCESSES
1922       vars_of_process_unix ();
1923 #endif
1924 #ifdef HAVE_WIN32_PROCESSES
1925       vars_of_process_nt ();
1926 #endif
1927 #endif
1928
1929       vars_of_profile ();
1930 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined(DOUG_LEA_MALLOC)
1931       vars_of_ralloc ();
1932 #endif /* HAVE_MMAP && REL_ALLOC */
1933       vars_of_redisplay ();
1934 #ifdef HAVE_SCROLLBARS
1935       vars_of_scrollbar ();
1936 #endif
1937       vars_of_search ();
1938       vars_of_select ();
1939       vars_of_sound ();
1940       vars_of_symbols ();
1941       vars_of_syntax ();
1942 #ifdef HAVE_TOOLBARS
1943       vars_of_toolbar ();
1944 #endif
1945       vars_of_undo ();
1946       vars_of_window ();
1947
1948 #ifdef HAVE_TTY
1949       vars_of_console_tty ();
1950       vars_of_frame_tty ();
1951       vars_of_objects_tty ();
1952 #endif
1953
1954 #ifdef HAVE_GTK
1955       vars_of_device_gtk ();
1956 #ifdef HAVE_DIALOGS
1957       vars_of_dialog_gtk ();
1958 #endif
1959       vars_of_event_gtk ();
1960       vars_of_frame_gtk ();
1961       vars_of_glyphs_gtk ();
1962       vars_of_ui_gtk ();
1963 #ifdef HAVE_MENUBARS
1964       vars_of_menubar_gtk ();
1965 #endif
1966       vars_of_objects_gtk ();
1967       vars_of_select_gtk ();
1968 #ifdef HAVE_SCROLLBARS
1969       vars_of_scrollbar_gtk ();
1970 #endif
1971 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
1972       vars_of_gui_gtk ();
1973 #endif
1974 #endif /* HAVE_GTK */
1975
1976 #ifdef HAVE_X_WINDOWS
1977 #ifdef HAVE_BALLOON_HELP
1978       vars_of_balloon_x ();
1979 #endif
1980       vars_of_device_x ();
1981 #ifdef HAVE_DIALOGS
1982       vars_of_dialog_x ();
1983 #endif
1984       vars_of_frame_x ();
1985       vars_of_glyphs_x ();
1986 #ifdef HAVE_MENUBARS
1987       vars_of_menubar_x ();
1988 #endif
1989       vars_of_objects_x ();
1990       vars_of_select_x ();
1991 #ifdef HAVE_SCROLLBARS
1992       vars_of_scrollbar_x ();
1993 #endif
1994 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
1995       vars_of_gui_x ();
1996 #endif
1997 #endif /* HAVE_X_WINDOWS */
1998
1999
2000 #ifdef HAVE_MS_WINDOWS
2001       vars_of_device_mswindows ();
2002       vars_of_console_mswindows ();
2003       vars_of_frame_mswindows ();
2004       vars_of_objects_mswindows ();
2005       vars_of_select_mswindows ();
2006       vars_of_glyphs_mswindows ();
2007 #ifdef HAVE_SCROLLBARS
2008       vars_of_scrollbar_mswindows ();
2009 #endif
2010 #ifdef HAVE_MENUBARS
2011       vars_of_menubar_mswindows ();
2012 #endif
2013 #ifdef HAVE_MSW_C_DIRED
2014       vars_of_dired_mswindows ();
2015 #endif
2016 #ifdef HAVE_DIALOGS
2017       vars_of_dialog_mswindows ();
2018 #endif
2019 #endif  /* HAVE_MS_WINDOWS */
2020
2021 #ifdef MULE
2022       vars_of_mule ();
2023       vars_of_mule_ccl ();
2024       vars_of_mule_charset ();
2025 #endif
2026 #ifdef FILE_CODING
2027       vars_of_file_coding ();
2028 #endif
2029 #ifdef MULE
2030 #ifdef HAVE_WNN
2031       vars_of_mule_wnn ();
2032 #endif
2033 #ifdef HAVE_CANNA
2034       vars_of_mule_canna ();
2035 #endif /* HAVE_CANNA */
2036 #endif /* MULE */
2037
2038 #ifdef TOOLTALK
2039       vars_of_tooltalk ();
2040 #endif
2041
2042 #ifdef SUNPRO
2043       vars_of_sunpro ();
2044 #endif
2045
2046 #ifdef HAVE_LDAP
2047       vars_of_eldap ();
2048 #endif
2049
2050 #ifdef HAVE_POSTGRESQL
2051       vars_of_postgresql();
2052 #endif
2053
2054 #ifdef HAVE_CONCORD
2055       vars_of_concord ();
2056 #endif
2057
2058 #ifdef HAVE_GPM
2059       vars_of_gpmevent ();
2060 #endif
2061
2062       /* Now initialize any specifier variables.  We do this later
2063          because it has some dependence on the vars initialized
2064          above.
2065
2066          These functions should *only* initialize specifier variables,
2067          and may make use of the following functions/macros in addition
2068          to the ones listed above:
2069
2070          DEFVAR_SPECIFIER()
2071          Fmake_specifier()
2072          set_specifier_fallback()
2073          set_specifier_caching()
2074          */
2075
2076       specifier_vars_of_glyphs ();
2077       specifier_vars_of_glyphs_widget ();
2078       specifier_vars_of_gutter ();
2079 #ifdef HAVE_MENUBARS
2080       specifier_vars_of_menubar ();
2081 #endif
2082       specifier_vars_of_redisplay ();
2083 #ifdef HAVE_SCROLLBARS
2084       specifier_vars_of_scrollbar ();
2085 #endif
2086 #ifdef HAVE_TOOLBARS
2087       specifier_vars_of_toolbar ();
2088 #endif
2089       specifier_vars_of_window ();
2090
2091       /* Now comes all the rest of the variables that couldn't
2092          be handled above.  There may be dependencies on variables
2093          initialized above, and dependencies between one complex_vars_()
2094          function and another. */
2095
2096       /* Calls Fmake_range_table(). */
2097       complex_vars_of_regex ();
2098       /* Calls Fmake_range_table(). */
2099       complex_vars_of_search ();
2100
2101       /* Calls make_lisp_hash_table(). */
2102       complex_vars_of_extents ();
2103
2104       /* Depends on hash tables and specifiers. */
2105       complex_vars_of_faces ();
2106
2107 #ifdef MULE
2108       /* These two depend on hash tables and various variables declared
2109          earlier.  The second may also depend on the first. */
2110       complex_vars_of_mule_charset ();
2111 #endif
2112 #ifdef FILE_CODING
2113       complex_vars_of_file_coding ();
2114 #endif
2115
2116       /* This calls allocate_glyph(), which creates specifiers
2117          and also relies on a variable (Vthe_nothing_vector) initialized
2118          above.  It also calls make_ext_string(), which under Mule
2119          could require that the charsets be initialized. */
2120       complex_vars_of_glyphs ();
2121
2122       /* These rely on the glyphs just created in the previous function,
2123          and call Fadd_spec_to_specifier(), which relies on various
2124          variables initialized above. */
2125 #ifdef HAVE_GTK
2126       complex_vars_of_glyphs_gtk ();
2127 #endif
2128 #ifdef HAVE_X_WINDOWS
2129       complex_vars_of_glyphs_x ();
2130 #endif
2131 #ifdef HAVE_MS_WINDOWS
2132       complex_vars_of_glyphs_mswindows ();
2133 #endif
2134
2135       /* This calls Fmake_glyph_internal(). */
2136       complex_vars_of_alloc ();
2137
2138       /* This calls Fmake_glyph_internal(). */
2139 #ifdef HAVE_MENUBARS
2140       complex_vars_of_menubar ();
2141 #endif
2142
2143       /* This calls Fmake_glyph_internal(). */
2144 #ifdef HAVE_SCROLLBARS
2145       complex_vars_of_scrollbar ();
2146 #endif
2147
2148       /* This calls allocate_glyph(). */
2149       complex_vars_of_frame ();
2150
2151       /* This calls Fcopy_category_table() under Mule, which calls who
2152          knows what. */
2153       complex_vars_of_chartab ();
2154
2155       /* This calls set_string_char(), which (under Mule) depends on the
2156          charsets being initialized. */
2157       complex_vars_of_casetab ();
2158
2159       /* This calls Fcopy_syntax_table(), which relies on char tables. */
2160       complex_vars_of_syntax ();
2161
2162       /* This initializes buffer-local variables, sets things up so
2163          that buffers can be created, and creates a couple of basic
2164          buffers.  This depends on Vstandard_syntax_table and
2165          Vstandard_category_table (initialized in the previous
2166          functions), as well as a whole horde of variables that may
2167          have been initialized above. */
2168       complex_vars_of_buffer ();
2169
2170       /* This initializes console-local variables. */
2171       complex_vars_of_console ();
2172
2173       /* This creates a couple more buffers, and depends on the
2174          previous function. */
2175       complex_vars_of_minibuf ();
2176
2177       /* These two might call Ffile_name_as_directory(), which
2178          might depend on all sorts of things; I'm not sure. */
2179       complex_vars_of_emacs ();
2180
2181       /* This creates a couple of basic keymaps and depends on Lisp
2182          hash tables and Ffset() (both of which depend on some variables
2183          initialized in the vars_of_*() section) and possibly other
2184          stuff. */
2185       complex_vars_of_keymap ();
2186
2187       /* Calls make_lisp_hash_table() and creates a keymap */
2188       complex_vars_of_event_stream ();
2189
2190 #ifdef ERROR_CHECK_GC
2191       {
2192         extern int always_gc;
2193         if (always_gc)                /* purification debugging hack */
2194           garbage_collect_1 ();
2195       }
2196 #endif
2197 #ifdef PDUMP
2198     } else if (!restart) {            /* after successful pdump_load() */
2199       reinit_alloc_once_early ();
2200       reinit_symbols_once_early ();
2201       reinit_opaque_once_early ();
2202
2203       reinit_console_type_create_stream ();
2204 #ifdef HAVE_TTY
2205       reinit_console_type_create_tty ();
2206 #endif
2207 #ifdef HAVE_X_WINDOWS
2208       reinit_console_type_create_x ();
2209       reinit_console_type_create_device_x ();
2210 #endif
2211 #ifdef HAVE_MS_WINDOWS
2212       reinit_console_type_create_mswindows ();
2213 #endif
2214 #ifdef HAVE_GTK
2215       reinit_console_type_create_gtk ();
2216 #endif
2217
2218       reinit_specifier_type_create ();
2219       reinit_specifier_type_create_image ();
2220       reinit_specifier_type_create_gutter ();
2221       reinit_specifier_type_create_objects ();
2222 #ifdef HAVE_TOOLBARS
2223       reinit_specifier_type_create_toolbar ();
2224 #endif
2225
2226       structure_type_create ();
2227
2228       structure_type_create_chartab ();
2229       structure_type_create_faces ();
2230       structure_type_create_rangetab ();
2231       structure_type_create_hash_table ();
2232 #ifdef HAVE_CONCORD
2233       structure_type_create_concord ();
2234 #endif
2235
2236       lstream_type_create ();
2237 #ifdef FILE_CODING
2238       lstream_type_create_file_coding ();
2239 #endif
2240 #if defined (HAVE_MS_WINDOWS) && !defined(HAVE_MSG_SELECT)
2241       lstream_type_create_mswindows_selectable ();
2242 #endif
2243 #ifdef HAVE_UNIX_PROCESSES
2244       process_type_create_unix ();
2245 #endif
2246 #ifdef HAVE_WIN32_PROCESSES
2247       process_type_create_nt ();
2248 #endif
2249
2250       reinit_vars_of_buffer ();
2251       reinit_vars_of_console ();
2252 #ifdef DEBUG_XEMACS
2253       reinit_vars_of_debug ();
2254 #endif
2255       reinit_vars_of_device ();
2256       reinit_vars_of_eval ();
2257 #ifdef HAVE_X_WINDOWS
2258       reinit_vars_of_event_Xt ();
2259 #endif
2260 #ifdef HAVE_GTK
2261       reinit_vars_of_event_gtk ();
2262 #endif
2263 #if defined(HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS))
2264       reinit_vars_of_event_tty ();
2265 #endif
2266 #ifdef HAVE_MS_WINDOWS
2267       reinit_vars_of_event_mswindows ();
2268 #endif
2269       reinit_vars_of_event_stream ();
2270       reinit_vars_of_events ();
2271       reinit_vars_of_extents ();
2272       reinit_vars_of_fileio ();
2273       reinit_vars_of_font_lock ();
2274       reinit_vars_of_glyphs ();
2275       reinit_vars_of_glyphs_widget ();
2276       reinit_vars_of_insdel ();
2277       reinit_vars_of_lread ();
2278       reinit_vars_of_lstream ();
2279       reinit_vars_of_minibuf ();
2280 #ifdef HAVE_SHLIB
2281       reinit_vars_of_module ();
2282 #endif
2283       reinit_vars_of_objects ();
2284       reinit_vars_of_print ();
2285       reinit_vars_of_search ();
2286       reinit_vars_of_undo ();
2287       reinit_vars_of_window ();
2288
2289 #ifdef HAVE_MS_WINDOWS
2290       reinit_vars_of_frame_mswindows ();
2291 #endif
2292
2293 #ifdef HAVE_GTK
2294       reinit_vars_of_menubar_gtk ();
2295 #endif
2296
2297 #ifdef HAVE_X_WINDOWS
2298       reinit_vars_of_device_x ();
2299 #ifdef HAVE_SCROLLBARS
2300       reinit_vars_of_scrollbar_x ();
2301 #endif
2302 #ifdef HAVE_MENUBARS
2303       reinit_vars_of_menubar_x ();
2304 #endif
2305       reinit_vars_of_select_x ();
2306 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
2307       reinit_vars_of_gui_x ();
2308 #endif
2309 #endif /* HAVE_X_WINDOWS */
2310
2311 #if defined(MULE) && defined(HAVE_WNN)
2312       reinit_vars_of_mule_wnn ();
2313 #endif
2314
2315       reinit_complex_vars_of_buffer ();
2316       reinit_complex_vars_of_console ();
2317       reinit_complex_vars_of_minibuf ();
2318 #endif /* PDUMP */
2319     }
2320
2321
2322   /* CONGRATULATIONS!!!  We have successfully initialized the Lisp
2323      engine. */
2324
2325   if (initialized)
2326     {
2327       /* Stuff that should not be done at dump time, including stuff that
2328          needs to be reset at run time.  Order below should not matter.
2329
2330          Many initializations taken from the environment should go here. */
2331       reinit_alloc ();
2332       reinit_eval ();
2333 #ifdef MULE_REGEXP
2334       reinit_mule_category ();
2335 #endif
2336 #ifdef HAVE_POSTGRESQL
2337       init_postgresql_from_environment();
2338 #endif
2339     }
2340
2341   /* Now do further initialization/setup of stuff that is not needed by the
2342      syms_of_() routines.  This involves stuff that only is enabled in
2343      an interactive run (redisplay, user input, etc.) and stuff that is
2344      not needed until we start loading Lisp code (the reader).  A lot
2345      of this stuff involves querying the current environment and needs
2346      to be done both at dump time and at run time. */
2347
2348   init_initial_directory();             /* get the directory to use for the
2349                                            "*scratch*" buffer, etc. */
2350
2351 #ifdef WIN32_NATIVE
2352   /*
2353    * For Win32, call init_environment() now, so that environment/registry
2354    * variables will be properly entered into Vprocess_environment.
2355    */
2356   init_environment();
2357 #endif
2358
2359   init_callproc ();     /* Set up the process environment (so that egetenv
2360                            works), the basic directory variables
2361                            (exec-directory and so on), and stuff
2362                            related to subprocesses.  This should be
2363                            first because many of the functions below
2364                            call egetenv() to get environment variables. */
2365   init_lread ();        /* Set up the Lisp reader. */
2366   init_cmdargs (argc, (Extbyte **) argv,
2367                 skip_args);     /* Create list Vcommand_line_args */
2368   init_buffer ();       /* Set default directory of *scratch* buffer */
2369
2370 #ifdef WIN32_NATIVE
2371   init_ntproc();
2372 #endif
2373
2374   init_redisplay ();      /* Determine terminal type.
2375                              init_sys_modes uses results */
2376   init_frame ();
2377   init_event_stream (); /* Set up so we can get user input. */
2378   init_macros (); /* set up so we can run macros. */
2379   init_editfns (); /* Determine the name of the user we're running as */
2380   init_xemacs_process (); /* set up for calling subprocesses */
2381 #ifdef SUNPRO
2382   init_sunpro (); /* Set up Sunpro usage tracking */
2383 #endif
2384 #if defined (WIN32_NATIVE) || defined (CYGWIN)
2385   init_win32 ();
2386 #endif
2387 #if defined (HAVE_NATIVE_SOUND) && defined (hp9000s800)
2388   init_hpplay ();
2389 #endif
2390 #ifdef HAVE_TTY
2391   init_device_tty ();
2392 #endif
2393   init_console_stream (restart); /* Create the first console */
2394
2395   /* try to get the actual pathname of the exec file we are running */
2396   if (!restart)
2397   {
2398     Vinvocation_name = Fcar (Vcommand_line_args);
2399     if (XSTRING_DATA(Vinvocation_name)[0] == '-')
2400       {
2401         /* XEmacs as a login shell, oh goody! */
2402         Vinvocation_name = build_string(getenv("SHELL"));
2403       }
2404     Vinvocation_directory = Vinvocation_name;
2405
2406     if (!NILP (Ffile_name_directory (Vinvocation_name)))
2407       {
2408         /* invocation-name includes a directory component -- presumably it
2409            is relative to cwd, not $PATH */
2410         Vinvocation_directory = Fexpand_file_name (Vinvocation_name,
2411                                                    Qnil);
2412         Vinvocation_path = Qnil;
2413       }
2414     else
2415       {
2416         Vinvocation_path = decode_env_path ("PATH", NULL);
2417         locate_file (Vinvocation_path, Vinvocation_name,
2418                      Vlisp_EXEC_SUFFIXES,
2419                      &Vinvocation_directory, X_OK);
2420       }
2421
2422     if (NILP (Vinvocation_directory))
2423       Vinvocation_directory = Vinvocation_name;
2424
2425     Vinvocation_name = Ffile_name_nondirectory (Vinvocation_directory);
2426     Vinvocation_directory = Ffile_name_directory (Vinvocation_directory);
2427   }
2428
2429 #if defined(HAVE_SHLIB) && !defined(WIN32_NATIVE)
2430   /* This is Unix only.  MS Windows NT has a library call that does
2431      The Right Thing on that system.  Rumor has it, this must be
2432      called for GNU dld in temacs and xemacs.  */
2433   {
2434     char *buf = (char *)alloca (XSTRING_LENGTH (Vinvocation_directory)
2435                                 + XSTRING_LENGTH (Vinvocation_name)
2436                                 + 2);
2437     sprintf (buf, "%s/%s", XSTRING_DATA (Vinvocation_directory),
2438              XSTRING_DATA (Vinvocation_name));
2439
2440     /* All we can do is cry if an error happens, so ignore it. */
2441     (void) dll_init (buf);
2442   }
2443 #endif
2444
2445 #if defined (LOCALTIME_CACHE) && defined (HAVE_TZSET)
2446   /* sun's localtime() has a bug.  it caches the value of the time
2447      zone rather than looking it up every time.  Since localtime() is
2448      called to bolt the undumping time into the undumped emacs, this
2449      results in localtime() ignoring the TZ environment variable.
2450      This flushes the new TZ value into localtime(). */
2451   tzset ();
2452 #endif /* LOCALTIME_CACHE and TZSET */
2453
2454   load_me = Qnil;
2455   if (!initialized)
2456     {
2457       /* Handle -l loadup-and-dump, args passed by Makefile. */
2458       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
2459         load_me = build_string (argv[2 + skip_args]);
2460 #if 0 /* CANNOT_DUMP - this can never be right in XEmacs --andyp */
2461       /* Unless next switch is -nl, load "loadup.el" first thing.  */
2462       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
2463         load_me = build_string ("loadup.el");
2464 #endif /* CANNOT_DUMP */
2465     }
2466
2467 #ifdef QUANTIFY
2468   if (initialized)
2469     quantify_start_recording_data ();
2470 #endif /* QUANTIFY */
2471
2472   initialized = 1;
2473   inhibit_non_essential_printing_operations = 0;
2474
2475   /* This never returns.  */
2476   initial_command_loop (load_me);
2477   /* NOTREACHED */
2478 }
2479
2480 \f
2481 /* Sort the args so we can find the most important ones
2482    at the beginning of argv.  */
2483
2484 /* First, here's a table of all the standard options.  */
2485
2486 struct standard_args
2487 {
2488   const char *name;
2489   const char *longname;
2490   int priority;
2491   int nargs;
2492 };
2493
2494 static const struct standard_args standard_args[] =
2495 {
2496   /* Handled by main_1 above: */
2497   { "-sd", "--show-dump-id", 105, 0 },
2498   { "-t", "--terminal", 100, 1 },
2499   { "-nd", "--no-dump-file", 95, 0 },
2500   { "-nw", "--no-windows", 90, 0 },
2501   { "-batch", "--batch", 85, 0 },
2502   { "-debug-paths", "--debug-paths", 82, 0 },
2503   { "-help", "--help", 80, 0 },
2504   { "-version", "--version", 75, 0 },
2505   { "-V", 0, 75, 0 },
2506   { "-d", "--display", 80, 1 },
2507   { "-display", 0, 80, 1 },
2508   { "-NXHost",  0, 79, 0 },
2509   { "-MachLaunch", 0, 79, 0},
2510
2511   /* Handled by command-line-early in startup.el: */
2512   { "-q", "--no-init-file", 50, 0 },
2513   { "-unmapped", 0, 50, 0 },
2514   { "-no-init-file", 0, 50, 0 },
2515   { "-vanilla", "--vanilla", 50, 0 },
2516   { "-no-autoloads", "--no-autoloads", 50, 0 },
2517   { "-no-site-file", "--no-site-file", 40, 0 },
2518   { "-no-early-packages", "--no-early-packages", 35, 0 },
2519   { "-u", "--user", 30, 1 },
2520   { "-user", 0, 30, 1 },
2521   { "-debug-init", "--debug-init", 20, 0 },
2522   { "-debug-paths", "--debug-paths", 20, 0 },
2523
2524   /* Xt options: */
2525   { "-i", "--icon-type", 15, 0 },
2526   { "-itype", 0, 15, 0 },
2527   { "-iconic", "--iconic", 15, 0 },
2528   { "-bg", "--background-color", 10, 1 },
2529   { "-background", 0, 10, 1 },
2530   { "-fg", "--foreground-color", 10, 1 },
2531   { "-foreground", 0, 10, 1 },
2532   { "-bd", "--border-color", 10, 1 },
2533   { "-bw", "--border-width", 10, 1 },
2534   { "-ib", "--internal-border", 10, 1 },
2535   { "-ms", "--mouse-color", 10, 1 },
2536   { "-cr", "--cursor-color", 10, 1 },
2537   { "-fn", "--font", 10, 1 },
2538   { "-font", 0, 10, 1 },
2539   { "-g", "--geometry", 10, 1 },
2540   { "-geometry", 0, 10, 1 },
2541   { "-T", "--title", 10, 1 },
2542   { "-title", 0, 10, 1 },
2543   { "-name", "--name", 10, 1 },
2544   { "-xrm", "--xrm", 10, 1 },
2545   { "-r", "--reverse-video", 5, 0 },
2546   { "-rv", 0, 5, 0 },
2547   { "-reverse", 0, 5, 0 },
2548   { "-hb", "--horizontal-scroll-bars", 5, 0 },
2549   { "-vb", "--vertical-scroll-bars", 5, 0 },
2550
2551   /* These have the same priority as ordinary file name args,
2552      so they are not reordered with respect to those.  */
2553   { "-L", "--directory", 0, 1 },
2554   { "-directory", 0, 0, 1 },
2555   { "-l", "--load", 0, 1 },
2556   { "-load", 0, 0, 1 },
2557   { "-f", "--funcall", 0, 1 },
2558   { "-funcall", 0, 0, 1 },
2559   { "-eval", "--eval", 0, 1 },
2560   { "-insert", "--insert", 0, 1 },
2561   /* This should be processed after ordinary file name args and the like.  */
2562   { "-kill", "--kill", -10, 0 },
2563 };
2564
2565 /* Reorder the elements of ARGV (assumed to have ARGC elements)
2566    so that the highest priority ones come first.
2567    Do not change the order of elements of equal priority.
2568    If an option takes an argument, keep it and its argument together.  */
2569
2570 static void
2571 sort_args (int argc, char **argv)
2572 {
2573   char **new_argv = xnew_array (char *, argc);
2574   /* For each element of argv,
2575      the corresponding element of options is:
2576      0 for an option that takes no arguments,
2577      1 for an option that takes one argument, etc.
2578      -1 for an ordinary non-option argument.  */
2579   int *options  = xnew_array (int, argc);
2580   int *priority = xnew_array (int, argc);
2581   int to = 1;
2582   int from;
2583   int i;
2584   int end_of_options_p = 0;
2585
2586   /* Categorize all the options,
2587      and figure out which argv elts are option arguments.  */
2588   for (from = 1; from < argc; from++)
2589     {
2590       options[from] = -1;
2591       priority[from] = 0;
2592       /* Pseudo options "--" and "run-temacs" indicate end of options */
2593       if (!strcmp (argv[from], "--") ||
2594           !strcmp (argv[from], "run-temacs"))
2595         end_of_options_p = 1;
2596       if (!end_of_options_p && argv[from][0] == '-')
2597         {
2598           int match, thislen;
2599           char *equals;
2600
2601           /* Look for a match with a known old-fashioned option.  */
2602           for (i = 0; i < countof (standard_args); i++)
2603             if (!strcmp (argv[from], standard_args[i].name))
2604               {
2605                 options[from]  = standard_args[i].nargs;
2606                 priority[from] = standard_args[i].priority;
2607                 if (from + standard_args[i].nargs >= argc)
2608                   fatal ("Option `%s' requires an argument\n", argv[from]);
2609                 from += standard_args[i].nargs;
2610                 goto done;
2611               }
2612
2613           /* Look for a match with a known long option.
2614              MATCH is -1 if no match so far, -2 if two or more matches so far,
2615              >= 0 (the table index of the match) if just one match so far.  */
2616           if (argv[from][1] == '-')
2617             {
2618               match = -1;
2619               thislen = strlen (argv[from]);
2620               equals = strchr (argv[from], '=');
2621               if (equals != 0)
2622                 thislen = equals - argv[from];
2623
2624               for (i = 0; i < countof (standard_args); i++)
2625                 if (standard_args[i].longname
2626                     && !strncmp (argv[from], standard_args[i].longname,
2627                                  thislen))
2628                   {
2629                     if (match == -1)
2630                       match = i;
2631                     else
2632                       match = -2;
2633                   }
2634
2635               /* If we found exactly one match, use that.  */
2636               if (match >= 0)
2637                 {
2638                   options[from]  = standard_args[match].nargs;
2639                   priority[from] = standard_args[match].priority;
2640                   /* If --OPTION=VALUE syntax is used,
2641                      this option uses just one argv element.  */
2642                   if (equals != 0)
2643                     options[from] = 0;
2644                   if (from + options[from] >= argc)
2645                     fatal ("Option `%s' requires an argument\n", argv[from]);
2646                   from += options[from];
2647                 }
2648             }
2649         done: ;
2650         }
2651     }
2652
2653   /* Copy the arguments, in order of decreasing priority, to NEW_ARGV.  */
2654   new_argv[0] = argv[0];
2655   while (to < argc)
2656     {
2657       int best = -1;
2658       int best_priority = -9999;
2659
2660       /* Find the highest priority remaining option.
2661          If several have equal priority, take the first of them.  */
2662       for (from = 1; from < argc; from++)
2663         {
2664           if (argv[from] != 0 && priority[from] > best_priority)
2665             {
2666               best_priority = priority[from];
2667               best = from;
2668             }
2669           /* Skip option arguments--they are tied to the options.  */
2670           if (options[from] > 0)
2671             from += options[from];
2672         }
2673
2674       if (best < 0)
2675         ABORT ();
2676
2677       /* Copy the highest priority remaining option, with its args, to NEW_ARGV.  */
2678       new_argv[to++] = argv[best];
2679       for (i = 0; i < options[best]; i++)
2680         new_argv[to++] = argv[best + i + 1];
2681
2682       /* Clear out this option in ARGV.  */
2683       argv[best] = 0;
2684       for (i = 0; i < options[best]; i++)
2685         argv[best + i + 1] = 0;
2686     }
2687
2688   memcpy (argv, new_argv, sizeof (char *) * argc);
2689   xfree (new_argv);
2690   xfree (options);
2691   xfree (priority);
2692 }
2693
2694 DEFUN ("running-temacs-p", Frunning_temacs_p, 0, 0, 0, /*
2695 True if running temacs.  This means we are in the dumping stage.
2696 This is false during normal execution of the `xemacs' program, and
2697 becomes false once `run-emacs-from-temacs' is run.
2698 */
2699        ())
2700 {
2701   return run_temacs_argc >= 0 ? Qt : Qnil;
2702 }
2703
2704 DEFUN ("run-emacs-from-temacs", Frun_emacs_from_temacs, 0, MANY, 0, /*
2705 Do not call this.  It will reinitialize your XEmacs.  You'll be sorry.
2706 */
2707 /* If this function is called from startup.el, it will be possible to run
2708    temacs as an editor using 'temacs -batch -l loadup.el run-temacs', instead
2709    of having to dump an emacs and then run that (when debugging emacs itself,
2710    this can be much faster)). [Actually, the speed difference isn't that
2711    much as long as your filesystem is local, and you don't end up with
2712    a dumped version in case you want to rerun it.  This function is most
2713    useful when used as part of the `make all-elc' command. --ben]
2714    This will "restart" emacs with the specified command-line arguments.
2715
2716    Martin thinks this function is most useful when using debugging
2717    tools like Purify or tcov that get confused by XEmacs' dumping.  */
2718      (int nargs, Lisp_Object *args))
2719 {
2720   int ac;
2721   const Extbyte *wampum;
2722   int namesize;
2723   int total_len;
2724   Lisp_Object orig_invoc_name = Fcar (Vcommand_line_args);
2725   const Extbyte **wampum_all = alloca_array (const Extbyte *, nargs);
2726   int *wampum_all_len  = alloca_array (int, nargs);
2727
2728   assert (!gc_in_progress);
2729
2730   if (run_temacs_argc < 0)
2731     error ("I've lost my temacs-hood.");
2732
2733   /* Need to convert the orig_invoc_name and all of the arguments
2734      to external format. */
2735
2736   TO_EXTERNAL_FORMAT (LISP_STRING, orig_invoc_name,
2737                       ALLOCA, (wampum, namesize),
2738                       Qnative);
2739   namesize++;
2740
2741   for (ac = 0, total_len = namesize; ac < nargs; ac++)
2742     {
2743       CHECK_STRING (args[ac]);
2744       TO_EXTERNAL_FORMAT (LISP_STRING, args[ac],
2745                           ALLOCA, (wampum_all[ac], wampum_all_len[ac]),
2746                           Qnative);
2747       wampum_all_len[ac]++;
2748       total_len += wampum_all_len[ac];
2749     }
2750   DO_REALLOC (run_temacs_args, run_temacs_args_size, total_len, char);
2751   DO_REALLOC (run_temacs_argv, run_temacs_argv_size, nargs+2, char *);
2752
2753   memcpy (run_temacs_args, wampum, namesize);
2754   run_temacs_argv [0] = run_temacs_args;
2755   for (ac = 0; ac < nargs; ac++)
2756     {
2757       memcpy (run_temacs_args + namesize,
2758               wampum_all[ac], wampum_all_len[ac]);
2759       run_temacs_argv [ac + 1] = run_temacs_args + namesize;
2760       namesize += wampum_all_len[ac];
2761     }
2762   run_temacs_argv [nargs + 1] = 0;
2763   catchlist = NULL; /* Important!  Otherwise free_cons() calls in
2764                        condition_case_unwind() may lead to GC death. */
2765   unbind_to (0, Qnil); /* this closes loadup.el */
2766   purify_flag = 0;
2767   run_temacs_argc = nargs + 1;
2768 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2769   report_sheap_usage (0);
2770 #endif
2771   LONGJMP (run_temacs_catch, 1);
2772   return Qnil; /* not reached; warning suppression */
2773 }
2774
2775 /* ARGSUSED */
2776 int
2777 main (int argc, char **argv, char **envp)
2778 {
2779
2780 #ifdef _MSC_VER
2781   /* Under VC++, access violations and the like are not sent through
2782      the standard signal() mechanism.  Rather, they need to be handled
2783      using the Microsoft "structured exception handling" mechanism,
2784      which vaguely resembles the C++ mechanisms. */
2785   __try
2786   {
2787 #endif
2788
2789   int     volatile vol_argc = argc;
2790   char ** volatile vol_argv = argv;
2791   char ** volatile vol_envp = envp;
2792   /* This is hairy.  We need to compute where the XEmacs binary was invoked
2793      from because temacs initialization requires it to find the lisp
2794      directories.  The code that recomputes the path is guarded by the
2795      restarted flag.  There are three possible paths I've found so far
2796      through this:
2797
2798      temacs -- When running temacs for basic build stuff, the first main_1
2799       will be the only one invoked.  It must compute the path else there
2800       will be a very ugly bomb in startup.el (can't find obvious location
2801       for doc-directory data-directory, etc.).
2802
2803      temacs w/ run-temacs on the command line -- This is run to bytecompile
2804       all the out of date dumped lisp.  It will execute both of the main_1
2805       calls and the second one must not touch the first computation because
2806       argc/argv are hosed the second time through.
2807
2808      xemacs -- Only the second main_1 is executed.  The invocation path must
2809       computed but this only matters when running in place or when running
2810       as a login shell.
2811
2812      As a bonus for straightening this out, XEmacs can now be run in place
2813      as a login shell.  This never used to work.
2814
2815      As another bonus, we can now guarantee that
2816      (concat invocation-directory invocation-name) contains the filename
2817      of the XEmacs binary we are running.  This can now be used in a
2818      definite test for out of date dumped files.  -slb */
2819   int restarted = 0;
2820 #ifdef QUANTIFY
2821   quantify_stop_recording_data ();
2822   quantify_clear_data ();
2823 #endif /* QUANTIFY */
2824
2825   inhibit_non_essential_printing_operations = 1;
2826   suppress_early_error_handler_backtrace = 0;
2827   lim_data = 0; /* force reinitialization of this variable */
2828
2829   /* Lisp_Object must fit in a word; check VALBITS and GCTYPEBITS */
2830   assert (sizeof (Lisp_Object) == sizeof (void *));
2831
2832 #ifdef LINUX_SBRK_BUG
2833   sbrk (1);
2834 #endif
2835
2836   if (!initialized)
2837     {
2838 #ifdef DOUG_LEA_MALLOC
2839       if (mallopt (M_MMAP_MAX, 0) != 1)
2840         ABORT();
2841 #endif
2842       run_temacs_argc = 0;
2843       if (! SETJMP (run_temacs_catch))
2844         {
2845           main_1 (vol_argc, vol_argv, vol_envp, 0);
2846         }
2847       /* run-emacs-from-temacs called */
2848       restarted = 1;
2849       vol_argc = run_temacs_argc;
2850       vol_argv = run_temacs_argv;
2851 #ifdef _SCO_DS
2852       /* This makes absolutely no sense to anyone involved.  There are
2853          several people using this stuff.  We've compared versions on
2854          everything we can think of.  We can find no difference.
2855          However, on both my systems environ is a plain old global
2856          variable initialized to zero.  _environ is the one that
2857          contains pointers to the actual environment.
2858
2859          Since we can't figure out the difference (and we're hours
2860          away from a release), this takes a very cowardly approach and
2861          is bracketed with both a system specific preprocessor test
2862          and a runtime "do you have this problem" test
2863
2864          06/20/96 robertl@dgii.com */
2865       {
2866         extern char **_environ;
2867         if ((unsigned) environ == 0)
2868           environ=_environ;
2869       }
2870 #endif /* _SCO_DS */
2871       vol_envp = environ;
2872     }
2873 #if defined (RUN_TIME_REMAP) && ! defined (PDUMP)
2874   else
2875     /* obviously no-one uses this because where it was before initialized was
2876      *always* true */
2877     run_time_remap (argv[0]);
2878 #endif
2879
2880 #ifdef DOUG_LEA_MALLOC
2881   if (initialized && (malloc_state_ptr != NULL))
2882     {
2883       int rc = malloc_set_state (malloc_state_ptr);
2884       if (rc != 0)
2885         {
2886           stderr_out ("malloc_set_state failed, rc = %d\n", rc);
2887           ABORT ();
2888         }
2889 #if 0
2890       free (malloc_state_ptr);
2891 #endif
2892       /* mmap works in glibc-2.1, glibc-2.0 (Non-Mule only) and Linux libc5 */
2893 #if (defined(__GLIBC__) && __GLIBC_MINOR__ >= 1) || \
2894     defined(_NO_MALLOC_WARNING_) || \
2895     (defined(__GLIBC__) && __GLIBC_MINOR__ < 1 && !defined(MULE)) || \
2896     defined(DEBUG_DOUG_LEA_MALLOC)
2897       if(mallopt (M_MMAP_MAX, 0) != 1)
2898         ABORT();
2899 #endif
2900 #ifdef REL_ALLOC
2901       r_alloc_reinit ();
2902 #endif
2903     }
2904 #endif /* DOUG_LEA_MALLOC */
2905
2906   run_temacs_argc = -1;
2907
2908   main_1 (vol_argc, vol_argv, vol_envp, restarted);
2909
2910 #ifdef _MSC_VER
2911   }
2912   /* VC++ documentation says that
2913      GetExceptionCode() cannot be called inside the filter itself. */
2914   __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {}
2915 #endif
2916
2917   return 0; /* unreached */
2918 }
2919
2920 \f
2921 /* Dumping apparently isn't supported by versions of GCC >= 2.8. */
2922 /* The following needs conditionalization on whether either XEmacs or */
2923 /* various system shared libraries have been built and linked with */
2924 /* GCC >= 2.8.  -slb */
2925 #if defined(GNU_MALLOC)
2926 static void
2927 voodoo_free_hook (void *mem)
2928 {
2929   /* Disable all calls to free() when XEmacs is exiting and it doesn't */
2930   /* matter. */
2931   __free_hook =
2932 #if defined __GNUC__ || defined __INTEL_COMPILER
2933 /* prototype of __free_hook varies with glibc version */
2934     (__typeof__ (__free_hook))
2935 #endif
2936     voodoo_free_hook;
2937 }
2938 #endif /* GNU_MALLOC */
2939
2940 DEFUN ("kill-emacs", Fkill_emacs, 0, 1, "P", /*
2941 Exit the XEmacs job and kill it.  Ask for confirmation, without argument.
2942 If ARG is an integer, return ARG as the exit program code.
2943 If ARG is a string, stuff it as keyboard input.
2944
2945 The value of `kill-emacs-hook', if not void,
2946 is a list of functions (of no args),
2947 all of which are called before XEmacs is actually killed.
2948 */
2949        (arg))
2950 {
2951   /* This function can GC */
2952   struct gcpro gcpro1;
2953
2954   GCPRO1 (arg);
2955
2956   if (feof (stdin))
2957     arg = Qt;
2958
2959   if (!preparing_for_armageddon && !noninteractive)
2960     run_hook (Qkill_emacs_hook);
2961
2962   ensure_no_quitting_from_now_on ();
2963
2964   if (!preparing_for_armageddon)
2965     {
2966       Lisp_Object concons, nextcons;
2967
2968       /* Normally, go ahead and delete all the consoles now.
2969          Some unmentionably lame window systems (MS Wwwww...... eek,
2970          I can't even say it) don't properly clean up after themselves,
2971          and even for those that do, it might be cleaner this way.
2972          If we're going down, however, we don't do this (might
2973          be too dangerous), and if we get a crash somewhere within
2974          this loop, we'll still autosave and won't try this again. */
2975
2976       LIST_LOOP_DELETING (concons, nextcons, Vconsole_list)
2977         {
2978           /* There is very little point in deleting the stream console.
2979              It uses stdio, which should flush any buffered output and
2980              something can only go wrong. -slb */
2981           /* I changed my mind.  There's a stupid hack in close to add
2982              a trailing newline. */
2983           /*if (!CONSOLE_STREAM_P (XCONSOLE (XCAR (concons))))*/
2984             delete_console_internal (XCONSOLE (XCAR (concons)), 1, 1, 0);
2985         }
2986     }
2987
2988   UNGCPRO;
2989
2990 #ifdef HAVE_MS_WINDOWS
2991   /* If we displayed a message on the console, then we must allow the
2992      user to see this message.  This may be unnecessary, but can't
2993      hurt, and we can't necessarily check arg; e.g. xemacs --help
2994      kills with argument 0.
2995
2996      Don't do this in batch mode, it makes no sense and is more
2997      annoying than useful. --andyp */
2998   if (mswindows_message_outputted && !noninteractive)
2999     Fmswindows_message_box (build_string ("Messages outputted.  XEmacs is exiting."),
3000                             Qnil, Qnil);
3001 #endif
3002
3003   shut_down_emacs (0, STRINGP (arg) ? arg : Qnil, 0);
3004
3005 #if defined(GNU_MALLOC)
3006   __free_hook =
3007 #if defined __GNUC__ || defined __INTEL_COMPILER
3008 /* prototype of __free_hook varies with glibc version */
3009     (__typeof__ (__free_hook))
3010 #endif
3011     voodoo_free_hook;
3012 #endif
3013
3014   exit (INTP (arg) ? XINT (arg) : 0);
3015   /* NOTREACHED */
3016   return Qnil; /* I'm sick of the compiler warning */
3017 }
3018
3019 /* Perform an orderly shutdown of XEmacs.  Autosave any modified
3020    buffers, kill any child processes, clean up the terminal modes (if
3021    we're in the foreground), and other stuff like that.  Don't perform
3022    any redisplay; this may be called when XEmacs is shutting down in
3023    the background, or after its X connection has died.
3024
3025    If SIG is a signal number, print a message for it.
3026
3027    This is called by fatal signal handlers and Fkill_emacs.  It used to
3028    be called by X protocol error handlers, but instead they now call
3029    Fkill_emacs. */
3030 static void
3031 shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save)
3032 {
3033   /* This function can GC */
3034   /* Prevent running of hooks and other non-essential stuff
3035      from now on.  */
3036   preparing_for_armageddon = 1;
3037
3038   ensure_no_quitting_from_now_on ();
3039
3040 #ifdef QUANTIFY
3041   quantify_stop_recording_data ();
3042 #endif /* QUANTIFY */
3043
3044   /* This is absolutely the most important thing to do, so make sure
3045      we do it now, before anything else.  We might have crashed and
3046      be in a weird inconsistent state, and potentially anything could
3047      set off another protection fault and cause us to bail out
3048      immediately. */
3049   /* Steve writes the following:
3050
3051      [[I'm not removing the code entirely, yet.  We have run up against
3052      a spate of problems in diagnosing crashes due to crashes within
3053      crashes.  It has very definitely been determined that code called
3054      during auto-saving cannot work if XEmacs crashed inside of GC.
3055      We already auto-save on an itimer so there cannot be too much
3056      unsaved stuff around, and if we get better crash reports we might
3057      be able to get more problems fixed so I'm disabling this.  -slb]]
3058
3059      and DISABLES AUTO-SAVING ENTIRELY during crashes!  Way way bad idea.
3060
3061      Instead let's just be more intelligent about avoiding crashing
3062      when possible, esp. nested crashes.
3063   */
3064   if (!no_auto_save)
3065     Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
3066
3067   fflush (stdout);
3068   reset_all_consoles ();
3069   if (sig && sig != SIGTERM)
3070     {
3071       if (sig == -1)
3072         stderr_out ("\nFatal error.\n\n");
3073       else
3074         stderr_out ("\nFatal error (%d).\n\n", sig);
3075       stderr_out
3076         ("Your files have been auto-saved.\n"
3077          "Use `M-x recover-session' to recover them.\n"
3078          "\n"
3079          "Your version of XEmacs was distributed with a PROBLEMS file that  may describe\n"
3080          "your crash, and with luck a workaround.  Please check it first, but do report\n"
3081          "the crash anyway.  "
3082 #ifdef INFODOCK
3083          "\n\nPlease report this bug by selecting `Report-Bug' in the InfoDock menu.\n"
3084          "*BE SURE* to include the XEmacs configuration from M-x describe-installation,\n"
3085          "or the file Installation in the top directory of the build tree.\n"
3086 #else
3087          "Please report this bug by invoking M-x report-emacs-bug,\n"
3088          "or by selecting `Send Bug Report' from the Help menu.  If necessary, send\n"
3089          "ordinary email to `xemacs-beta@xemacs.org'.  *MAKE SURE* to include the XEmacs\n"
3090          "configuration from M-x describe-installation, or equivalently the file\n"
3091          "Installation in the top of the build tree.\n"
3092 #endif
3093 #ifndef _MSC_VER
3094          "\n"
3095          "*Please* try *hard* to obtain a C stack backtrace; without it, we are unlikely\n"
3096          "to be able to analyze the problem.  Locate the core file produced as a result\n"
3097          "of this crash (often called `core' or `core.<process-id>', and located in\n"
3098          "the directory in which you started XEmacs or your home directory), and type\n"
3099          "\n"
3100          "  gdb "
3101 #endif
3102          );
3103 #ifndef _MSC_VER
3104       {
3105         const char *name;
3106         char *dir = 0;
3107
3108         /* Now try to determine the actual path to the executable,
3109            to try to make the backtrace-determination process as foolproof
3110            as possible. */
3111         if (STRINGP (Vinvocation_name))
3112           name = (char *) XSTRING_DATA (Vinvocation_name);
3113         else
3114           name = "xemacs";
3115         if (STRINGP (Vinvocation_directory))
3116           dir = (char *) XSTRING_DATA (Vinvocation_directory);
3117         if (!dir || dir[0] != '/')
3118           stderr_out ("`which %s`", name);
3119         else if (dir[strlen (dir) - 1] != '/')
3120           stderr_out ("%s/%s", dir, name);
3121         else
3122           stderr_out ("%s%s", dir, name);
3123       }
3124       stderr_out
3125         (" core\n"
3126          "\n"
3127          "then type `where' at the debugger prompt.  No GDB on your system?  You may\n"
3128          "have DBX, or XDB, or SDB.  (Ask your system administrator if you need help.)\n"
3129          "If no core file was produced, enable them (often with `ulimit -c unlimited'\n"
3130          "in case of future recurrance of the crash.\n");
3131 #endif /* _MSC_VER */
3132     }
3133
3134   stuff_buffered_input (stuff);
3135
3136   kill_buffer_processes (Qnil);
3137
3138 #ifdef CLASH_DETECTION
3139   unlock_all_files ();
3140 #endif
3141
3142 #ifdef TOOLTALK
3143   tt_session_quit (tt_default_session ());
3144 #if 0
3145   /* The following crashes when built on X11R5 and run on X11R6 */
3146   tt_close ();
3147 #endif
3148 #endif /* TOOLTALK */
3149
3150 }
3151
3152 \f
3153 #ifndef CANNOT_DUMP
3154
3155 #if !defined(PDUMP) || !defined(SYSTEM_MALLOC)
3156 extern char my_edata[];
3157 #endif
3158
3159 extern void disable_free_hook (void);
3160
3161 DEFUN ("dump-emacs", Fdump_emacs, 2, 2, 0, /*
3162 Dump current state of XEmacs into executable file FILENAME.
3163 Take symbols from SYMFILE (presumably the file you executed to run XEmacs).
3164 This is used in the file `loadup.el' when building XEmacs.
3165
3166 Remember to set `command-line-processed' to nil before dumping
3167 if you want the dumped XEmacs to process its command line
3168 and announce itself normally when it is run.
3169 */
3170        (filename, symfile))
3171 {
3172   /* This function can GC */
3173   struct gcpro gcpro1, gcpro2;
3174   int opurify;
3175
3176   GCPRO2 (filename, symfile);
3177
3178 #ifdef FREE_CHECKING
3179   Freally_free (Qnil);
3180
3181   /* When we're dumping, we can't use the debugging free() */
3182   disable_free_hook ();
3183 #endif
3184
3185   CHECK_STRING (filename);
3186   filename = Fexpand_file_name (filename, Qnil);
3187   if (!NILP (symfile))
3188     {
3189       CHECK_STRING (symfile);
3190       if (XSTRING_LENGTH (symfile) > 0)
3191         symfile = Fexpand_file_name (symfile, Qnil);
3192       else
3193         symfile = Qnil;
3194     }
3195
3196   opurify = purify_flag;
3197   purify_flag = 0;
3198
3199 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
3200   report_sheap_usage (1);
3201 #endif
3202
3203   clear_message ();
3204
3205   fflush (stderr);
3206   fflush (stdout);
3207
3208   disksave_object_finalization ();
3209   release_breathing_space ();
3210
3211   /* Tell malloc where start of impure now is */
3212   /* Also arrange for warnings when nearly out of space.  */
3213 #ifndef SYSTEM_MALLOC
3214   memory_warnings (my_edata, malloc_warning);
3215 #endif
3216
3217   UNGCPRO;
3218
3219   {
3220     char *filename_ext;
3221     char *symfile_ext;
3222
3223     LISP_STRING_TO_EXTERNAL (filename, filename_ext, Qfile_name);
3224
3225     if (STRINGP (symfile))
3226       LISP_STRING_TO_EXTERNAL (symfile, symfile_ext, Qfile_name);
3227     else
3228       symfile_ext = 0;
3229
3230     garbage_collect_1 ();
3231
3232 #ifdef PDUMP
3233     pdump ();
3234 #else
3235
3236 #ifdef DOUG_LEA_MALLOC
3237     malloc_state_ptr = malloc_get_state ();
3238 #endif
3239   /* here we break our rule that the filename conversion should
3240      be performed at the actual time that the system call is made.
3241      It's a whole lot easier to do the conversion here than to
3242      modify all the unexec routines to ensure that filename
3243      conversion is applied everywhere.  Don't worry about memory
3244      leakage because this call only happens once. */
3245     unexec (filename_ext, symfile_ext, (uintptr_t) my_edata, 0, 0);
3246 #ifdef DOUG_LEA_MALLOC
3247     free (malloc_state_ptr);
3248 #endif
3249 #endif /* not PDUMP */
3250   }
3251
3252   purify_flag = opurify;
3253
3254   return Qnil;
3255 }
3256
3257 #endif /* not CANNOT_DUMP */
3258 \f
3259
3260 /* Split STRING into a list of substrings.  The substrings are the
3261    parts of original STRING separated by SEPCHAR.  */
3262 static Lisp_Object
3263 split_string_by_emchar_1 (const Bufbyte *string, Bytecount size,
3264                           Emchar sepchar)
3265 {
3266   Lisp_Object result = Qnil;
3267   const Bufbyte *end = string + size;
3268
3269   while (1)
3270     {
3271       const Bufbyte *p = string;
3272       while (p < end)
3273         {
3274           if (charptr_emchar (p) == sepchar)
3275             break;
3276           INC_CHARPTR (p);
3277         }
3278       result = Fcons (make_string (string, p - string), result);
3279       if (p < end)
3280         {
3281           string = p;
3282           INC_CHARPTR (string); /* skip sepchar */
3283         }
3284       else
3285         break;
3286     }
3287   return Fnreverse (result);
3288 }
3289
3290 /* The same as the above, except PATH is an external C string (it is
3291    converted using Qfile_name), and sepchar is hardcoded to SEPCHAR
3292    (':' or whatever).  */
3293 Lisp_Object
3294 decode_path (const char *path)
3295 {
3296   Bytecount newlen;
3297   Bufbyte *newpath;
3298   if (!path)
3299     return Qnil;
3300
3301   TO_INTERNAL_FORMAT (C_STRING, path, ALLOCA, (newpath, newlen), Qfile_name);
3302
3303   /* #### Does this make sense?  It certainly does for
3304      decode_env_path(), but it looks dubious here.  Does any code
3305      depend on decode_path("") returning nil instead of an empty
3306      string?  */
3307   if (!newlen)
3308     return Qnil;
3309
3310   return split_string_by_emchar_1 (newpath, newlen, SEPCHAR);
3311 }
3312
3313 Lisp_Object
3314 decode_env_path (const char *evarname, const char *default_)
3315 {
3316   const char *path = 0;
3317   if (evarname)
3318     path = egetenv (evarname);
3319   if (!path)
3320     path = default_;
3321   return decode_path (path);
3322 }
3323
3324 /* Ben thinks this function should not exist or be exported to Lisp.
3325    We use it to define split-path-string in subr.el (not!).  */
3326
3327 DEFUN ("split-string-by-char", Fsplit_string_by_char, 2, 2, 0, /*
3328 Split STRING into a list of substrings originally separated by SEPCHAR.
3329 */
3330        (string, sepchar))
3331 {
3332   CHECK_STRING (string);
3333   CHECK_CHAR (sepchar);
3334   return split_string_by_emchar_1 (XSTRING_DATA (string),
3335                                    XSTRING_LENGTH (string),
3336                                    XCHAR (sepchar));
3337 }
3338
3339 /* #### This was supposed to be in subr.el, but is used VERY early in
3340    the bootstrap process, so it goes here.  Damn.  */
3341
3342 DEFUN ("split-path", Fsplit_path, 1, 1, 0, /*
3343 Explode a search path into a list of strings.
3344 The path components are separated with the characters specified
3345 with `path-separator'.
3346 */
3347        (path))
3348 {
3349   CHECK_STRING (path);
3350
3351   while (!STRINGP (Vpath_separator)
3352          || (XSTRING_CHAR_LENGTH (Vpath_separator) != 1))
3353     Vpath_separator = signal_simple_continuable_error
3354       ("`path-separator' should be set to a single-character string",
3355        Vpath_separator);
3356
3357   return (split_string_by_emchar_1
3358           (XSTRING_DATA (path), XSTRING_LENGTH (path),
3359            charptr_emchar (XSTRING_DATA (Vpath_separator))));
3360 }
3361 \f
3362 DEFUN ("noninteractive", Fnoninteractive, 0, 0, 0, /*
3363 Non-nil return value means XEmacs is running without interactive terminal.
3364 */
3365        ())
3366 {
3367   return noninteractive ? Qt : Qnil;
3368 }
3369
3370 /* This flag is useful to define if you're under a debugger; this way, you
3371    can put a breakpoint of assert_failed() and debug multiple problems
3372    in one session without having to recompile. */
3373 /* #define ASSERTIONS_DONT_ABORT */
3374
3375 /* This highly dubious kludge ... shut up Jamie, I'm tired of your slagging. */
3376
3377 static int in_assert_failed;
3378 static const char *assert_failed_file;
3379 static int assert_failed_line;
3380 static const char *assert_failed_expr;
3381
3382 #ifdef fprintf
3383 #undef fprintf
3384 #endif
3385
3386 #if defined (WIN32_NATIVE) && defined (DEBUG_XEMACS)
3387 #define enter_debugger() DebugBreak ()
3388 #else
3389 #define enter_debugger()
3390 #endif
3391
3392 void
3393 assert_failed (const char *file, int line, const char *expr)
3394 {
3395   /* If we're already crashing, let's not crash again.  This might be
3396      critical to getting auto-saving working properly. */
3397   if (fatal_error_in_progress)
3398     return;
3399
3400   /* We are extremely paranoid so we sensibly deal with recursive
3401      assertion failures. */
3402   in_assert_failed++;
3403   inhibit_non_essential_printing_operations = 1;
3404
3405   if (in_assert_failed >= 4)
3406     _exit (-1);
3407   else if (in_assert_failed == 3)
3408     {
3409       enter_debugger ();
3410       _exit (-1);
3411     }
3412   else if (in_assert_failed == 2)
3413     {
3414       /* Not stderr_out(), which does additional things and may trigger
3415          a recursive assertion failure.  fprintf was undeffed above, in
3416          case it was encapsulated. */
3417       fprintf (stderr,
3418                "Fatal error: recursive assertion failure, "
3419                "file %s, line %d, %s\n",
3420                file, line, expr);
3421       fprintf (stderr,
3422                "Original assertion failure: file %s, line %d, %s\n",
3423                assert_failed_file, assert_failed_line, assert_failed_expr);
3424     }
3425   else
3426     {
3427       assert_failed_file = file;
3428       assert_failed_line = line;
3429       assert_failed_expr = expr;
3430
3431       if (!initialized)
3432         fprintf (stderr,
3433                  "Fatal error: assertion failed, file %s, line %d, %s\n",
3434                  file, line, expr);
3435       else
3436         stderr_out ("Fatal error: assertion failed, file %s, line %d, %s\n",
3437                     file, line, expr);
3438     }
3439
3440   enter_debugger ();
3441 #if !defined (ASSERTIONS_DONT_ABORT)
3442   abort (); /* The real abort(), this time */
3443 #endif
3444   inhibit_non_essential_printing_operations = 0;
3445   in_assert_failed = 0;
3446 }
3447
3448 #ifdef QUANTIFY
3449 DEFUN ("quantify-start-recording-data", Fquantify_start_recording_data,
3450        0, 0, "", /*
3451 Start recording Quantify data.
3452 */
3453        ())
3454 {
3455   quantify_start_recording_data ();
3456   return Qnil;
3457 }
3458
3459 DEFUN ("quantify-stop-recording-data", Fquantify_stop_recording_data,
3460        0, 0, "", /*
3461 Stop recording Quantify data.
3462 */
3463        ())
3464 {
3465   quantify_stop_recording_data ();
3466   return Qnil;
3467 }
3468
3469 DEFUN ("quantify-clear-data", Fquantify_clear_data, 0, 0, "", /*
3470 Clear all Quantify data.
3471 */
3472        ())
3473 {
3474   quantify_clear_data ();
3475   return Qnil;
3476 }
3477 #endif /* QUANTIFY */
3478
3479 void
3480 syms_of_emacs (void)
3481 {
3482 #ifndef CANNOT_DUMP
3483   DEFSUBR (Fdump_emacs);
3484 #endif /* !CANNOT_DUMP */
3485
3486   DEFSUBR (Frun_emacs_from_temacs);
3487   DEFSUBR (Frunning_temacs_p);
3488   DEFSUBR (Finvocation_name);
3489   DEFSUBR (Finvocation_directory);
3490   DEFSUBR (Fkill_emacs);
3491   DEFSUBR (Fnoninteractive);
3492
3493 #ifdef DEBUG_XEMACS
3494   DEFSUBR (Fforce_debugging_signal);
3495 #endif
3496
3497 #ifdef QUANTIFY
3498   DEFSUBR (Fquantify_start_recording_data);
3499   DEFSUBR (Fquantify_stop_recording_data);
3500   DEFSUBR (Fquantify_clear_data);
3501 #endif /* QUANTIFY */
3502
3503   DEFSUBR (Fsplit_string_by_char);
3504   DEFSUBR (Fsplit_path);        /* #### */
3505
3506   defsymbol (&Qkill_emacs_hook, "kill-emacs-hook");
3507   defsymbol (&Qsave_buffers_kill_emacs, "save-buffers-kill-emacs");
3508 }
3509
3510 void
3511 vars_of_emacs (void)
3512 {
3513   DEFVAR_BOOL ("suppress-early-error-handler-backtrace",
3514                &suppress_early_error_handler_backtrace /*
3515 Non-nil means early error handler shouldn't print a backtrace.
3516 */ );
3517
3518   DEFVAR_LISP ("command-line-args", &Vcommand_line_args /*
3519 Args passed by shell to XEmacs, as a list of strings.
3520 */ );
3521
3522   DEFVAR_LISP ("invocation-name", &Vinvocation_name /*
3523 The program name that was used to run XEmacs.
3524 Any directory names are omitted.
3525 */ );
3526
3527   DEFVAR_LISP ("invocation-directory", &Vinvocation_directory /*
3528 The directory in which the XEmacs executable was found, to run it.
3529 The value is simply the program name if that directory's name is not known.
3530 */ );
3531
3532   DEFVAR_LISP ("invocation-path", &Vinvocation_path /*
3533 The path in which the XEmacs executable was found, to run it.
3534 The value is simply the value of environment variable PATH on startup
3535 if XEmacs was found there.
3536 */ );
3537
3538 #if 0 /* FSFmacs */
3539   xxDEFVAR_LISP ("installation-directory", &Vinstallation_directory,
3540     "A directory within which to look for the `lib-src' and `etc' directories.\n"
3541 "This is non-nil when we can't find those directories in their standard\n"
3542 "installed locations, but we can find them\n"
3543 "near where the XEmacs executable was found.");
3544 #endif
3545
3546   DEFVAR_LISP ("system-type", &Vsystem_type /*
3547 Symbol indicating type of operating system you are using.
3548 */ );
3549   Vsystem_type = intern (SYSTEM_TYPE);
3550   Fprovide (intern(SYSTEM_TYPE));
3551
3552 #ifndef EMACS_CONFIGURATION
3553 # define EMACS_CONFIGURATION "UNKNOWN"
3554 #endif
3555   DEFVAR_LISP ("system-configuration", &Vsystem_configuration /*
3556 String naming the configuration XEmacs was built for.
3557 */ );
3558   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
3559
3560 #ifndef EMACS_CONFIG_OPTIONS
3561 # define EMACS_CONFIG_OPTIONS "UNKNOWN"
3562 #endif
3563   DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options /*
3564 String containing the configuration options XEmacs was built with.
3565 */ );
3566   Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS);
3567
3568   DEFVAR_LISP ("emacs-major-version", &Vemacs_major_version /*
3569 Major version number of this version of Emacs, as an integer.
3570 Warning: this variable did not exist in Emacs versions earlier than:
3571   FSF Emacs:   19.23
3572   XEmacs:      19.10
3573 */ );
3574   Vemacs_major_version = make_int (EMACS_MAJOR_VERSION);
3575
3576   DEFVAR_LISP ("emacs-minor-version", &Vemacs_minor_version /*
3577 Minor version number of this version of Emacs, as an integer.
3578 Warning: this variable did not exist in Emacs versions earlier than:
3579   FSF Emacs:   19.23
3580   XEmacs:      19.10
3581 */ );
3582   Vemacs_minor_version = make_int (EMACS_MINOR_VERSION);
3583
3584   DEFVAR_LISP ("emacs-patch-level", &Vemacs_patch_level /*
3585 The patch level of this version of Emacs, as an integer.
3586 The value is non-nil if this version of XEmacs is part of a series of
3587 stable XEmacsen, but has bug fixes applied.
3588 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3589 earlier than 21.1.1
3590 */ );
3591 #ifdef EMACS_PATCH_LEVEL
3592   Vemacs_patch_level = make_int (EMACS_PATCH_LEVEL);
3593 #else
3594   Vemacs_patch_level = Qnil;
3595 #endif
3596
3597     DEFVAR_LISP ("emacs-beta-version", &Vemacs_beta_version /*
3598 Beta number of this version of Emacs, as an integer.
3599 The value is nil if this is an officially released version of XEmacs.
3600 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3601 earlier than 20.3.
3602 */ );
3603 #ifdef EMACS_BETA_VERSION
3604   Vemacs_beta_version = make_int (EMACS_BETA_VERSION);
3605 #else
3606   Vemacs_beta_version = Qnil;
3607 #endif
3608
3609 #ifdef INFODOCK
3610   DEFVAR_LISP ("infodock-major-version", &Vinfodock_major_version /*
3611 Major version number of this InfoDock release.
3612 */ );
3613   Vinfodock_major_version = make_int (INFODOCK_MAJOR_VERSION);
3614
3615   DEFVAR_LISP ("infodock-minor-version", &Vinfodock_minor_version /*
3616 Minor version number of this InfoDock release.
3617 */ );
3618   Vinfodock_minor_version = make_int (INFODOCK_MINOR_VERSION);
3619
3620   DEFVAR_LISP ("infodock-build-version", &Vinfodock_build_version /*
3621 Build version of this InfoDock release.
3622 */ );
3623   Vinfodock_build_version = make_int (INFODOCK_BUILD_VERSION);
3624 #endif
3625
3626   DEFVAR_LISP ("xemacs-codename", &Vxemacs_codename /*
3627 Codename of this version of Emacs (a string).
3628 */ );
3629 #ifndef XEMACS_CODENAME
3630 #define XEMACS_CODENAME "Noname"
3631 #endif
3632 #ifdef MULE
3633   {
3634     char dest[129];
3635     char src[64] = XEMACS_CODENAME;
3636     unsigned char* sp = (unsigned char*)src;
3637     int i = 0, chr;
3638
3639     while ( (chr = *sp++) && (i < 128) )
3640       {
3641         if (chr <= 0x7F)
3642           dest[i++] = chr;
3643         else
3644           {
3645 #ifdef UTF2000
3646             dest[i++] = (chr >> 6) | 0xC0;
3647             dest[i++] = (chr & 0x3F) | 0x80;
3648 #else
3649             dest[i++] = LEADING_BYTE_LATIN_ISO8859_1;
3650             dest[i++] = chr;
3651 #endif
3652           }
3653       }
3654     dest[i] = 0;
3655     Vxemacs_codename = build_string (dest);
3656   }
3657 #else  
3658   Vxemacs_codename = build_string (XEMACS_CODENAME);
3659 #endif
3660
3661   /* Lisp variables which contain command line flags.
3662
3663      The portable dumper stomps on these; they must be saved and restored
3664      if they are processed before the call to pdump_load() in main_1().
3665   */
3666   DEFVAR_BOOL ("noninteractive", &noninteractive1 /*
3667 Non-nil means XEmacs is running without interactive terminal.
3668 */ );
3669
3670   DEFVAR_BOOL ("inhibit-early-packages", &inhibit_early_packages /*
3671 Set to non-nil when the early packages should not be respected at startup.
3672 */ );
3673
3674   DEFVAR_BOOL ("inhibit-autoloads", &inhibit_autoloads /*
3675 Set to non-nil when autoloads should not be loaded at startup.
3676 */ );
3677
3678   DEFVAR_BOOL ("debug-paths", &debug_paths /*
3679 Set to non-nil when debug information about paths should be printed.
3680 */ );
3681
3682   DEFVAR_BOOL ("inhibit-site-lisp", &inhibit_site_lisp /*
3683 Set to non-nil when the site-lisp should not be searched at startup.
3684 */ );
3685 #ifdef INHIBIT_SITE_LISP
3686   inhibit_site_lisp = 1;
3687 #endif
3688
3689   DEFVAR_BOOL ("inhibit-site-modules", &inhibit_site_modules /*
3690 Set to non-nil when site-modules should not be searched at startup.
3691 */ );
3692 #ifdef INHIBIT_SITE_MODULES
3693   inhibit_site_modules = 1;
3694 #endif
3695
3696   DEFVAR_INT ("emacs-priority", &emacs_priority /*
3697 Priority for XEmacs to run at.
3698 This value is effective only if set before XEmacs is dumped,
3699 and only if the XEmacs executable is installed with setuid to permit
3700 it to change priority.  (XEmacs sets its uid back to the real uid.)
3701 Currently, you need to define SET_EMACS_PRIORITY in `config.h'
3702 before you compile XEmacs, to enable the code for this feature.
3703 */ );
3704   emacs_priority = 0;
3705
3706   DEFVAR_CONST_LISP ("internal-error-checking", &Vinternal_error_checking /*
3707 Internal error checking built-in into this instance of XEmacs.
3708 This is a list of symbols, initialized at build-time.  Legal symbols
3709 are:
3710
3711 extents         - check extents prior to each extent change;
3712 typecheck       - check types strictly, aborting in case of error;
3713 malloc          - check operation of malloc;
3714 gc              - check garbage collection;
3715 bufpos          - check buffer positions.
3716
3717 quick-build     - user has requested the "quick-build" configure option.
3718 */ );
3719   Vinternal_error_checking = Qnil;
3720 #ifdef ERROR_CHECK_EXTENTS
3721   Vinternal_error_checking = Fcons (intern ("extents"),
3722                                     Vinternal_error_checking);
3723 #endif
3724 #ifdef ERROR_CHECK_TYPECHECK
3725   Vinternal_error_checking = Fcons (intern ("typecheck"),
3726                                     Vinternal_error_checking);
3727 #endif
3728 #ifdef ERROR_CHECK_MALLOC
3729   Vinternal_error_checking = Fcons (intern ("malloc"),
3730                                     Vinternal_error_checking);
3731 #endif
3732 #ifdef ERROR_CHECK_GC
3733   Vinternal_error_checking = Fcons (intern ("gc"),
3734                                     Vinternal_error_checking);
3735 #endif
3736 #ifdef ERROR_CHECK_BUFPOS
3737   Vinternal_error_checking = Fcons (intern ("bufpos"),
3738                                     Vinternal_error_checking);
3739 #endif
3740 #ifdef QUICK_BUILD
3741   Vinternal_error_checking = Fcons (intern ("quick-build"),
3742                                     Vinternal_error_checking);
3743 #endif
3744
3745   DEFVAR_CONST_LISP ("mail-lock-methods", &Vmail_lock_methods /*
3746 Mail spool locking methods supported by this instance of XEmacs.
3747 This is a list of symbols.  Each of the symbols is one of the
3748 following: dot, lockf, flock, locking, mmdf.
3749 */ );
3750   {
3751     Vmail_lock_methods = Qnil;
3752     Vmail_lock_methods = Fcons (intern ("dot"), Vmail_lock_methods);
3753 #ifdef HAVE_LOCKF
3754     Vmail_lock_methods = Fcons (intern ("lockf"), Vmail_lock_methods);
3755 #endif
3756 #ifdef HAVE_FLOCK
3757     Vmail_lock_methods = Fcons (intern ("flock"), Vmail_lock_methods);
3758 #endif
3759 #ifdef HAVE_MMDF
3760     Vmail_lock_methods = Fcons (intern ("mmdf"), Vmail_lock_methods);
3761 #endif
3762 #ifdef HAVE_LOCKING
3763     Vmail_lock_methods = Fcons (intern ("locking"), Vmail_lock_methods);
3764 #endif
3765   }
3766
3767   DEFVAR_CONST_LISP ("configure-mail-lock-method", &Vconfigure_mail_lock_method /*
3768 Mail spool locking method suggested by configure.  This is one
3769 of the symbols in MAIL-LOCK-METHODS.
3770 */ );
3771   {
3772 #if defined(MAIL_LOCK_FLOCK) && defined(HAVE_FLOCK)
3773     Vconfigure_mail_lock_method = intern("flock");
3774 #elif defined(MAIL_LOCK_LOCKF) && defined(HAVE_LOCKF)
3775     Vconfigure_mail_lock_method = intern("lockf");
3776 #elif defined(MAIL_LOCK_MMDF) && defined(HAVE_MMDF)
3777     Vconfigure_mail_lock_method = intern("mmdf");
3778 #elif defined(MAIL_LOCK_LOCKING) && defined(HAVE_LOCKING)
3779     Vconfigure_mail_lock_method = intern("locking");
3780 #else
3781     Vconfigure_mail_lock_method = intern("dot");
3782 #endif
3783   }
3784
3785   DEFVAR_LISP ("path-separator", &Vpath_separator /*
3786 The directory separator in search paths, as a string.
3787 */ );
3788   {
3789     char c = SEPCHAR;
3790     Vpath_separator = make_string ((Bufbyte *)&c, 1);
3791   }
3792 }
3793
3794 void
3795 complex_vars_of_emacs (void)
3796 {
3797   /* This is all related to path searching. */
3798
3799   DEFVAR_LISP ("emacs-program-name", &Vemacs_program_name /*
3800 *Name of the Emacs variant.
3801 For example, this may be \"xemacs\" or \"infodock\".
3802 This is mainly meant for use in path searching.
3803 */ );
3804   Vemacs_program_name = build_string ((char *) PATH_PROGNAME);
3805
3806   DEFVAR_LISP ("emacs-program-version", &Vemacs_program_version /*
3807 *Version of the Emacs variant.
3808 This typically has the form NN.NN-bNN.
3809 This is mainly meant for use in path searching.
3810 */ );
3811   Vemacs_program_version = build_string ((char *) PATH_VERSION);
3812
3813   DEFVAR_LISP ("exec-path", &Vexec_path /*
3814 *List of directories to search programs to run in subprocesses.
3815 Each element is a string (directory name) or nil (try default directory).
3816 */ );
3817   Vexec_path = Qnil;
3818
3819   DEFVAR_LISP ("exec-directory", &Vexec_directory /*
3820 *Directory of architecture-dependent files that come with XEmacs,
3821 especially executable programs intended for XEmacs to invoke.
3822 */ );
3823   Vexec_directory = Qnil;
3824
3825   DEFVAR_LISP ("configure-exec-directory", &Vconfigure_exec_directory /*
3826 For internal use by the build procedure only.
3827 configure's idea of what `exec-directory' will be.
3828 */ );
3829 #ifdef PATH_EXEC
3830   Vconfigure_exec_directory = Ffile_name_as_directory
3831     (build_string ((char *) PATH_EXEC));
3832 #else
3833   Vconfigure_exec_directory = Qnil;
3834 #endif
3835
3836   DEFVAR_LISP ("lisp-directory", &Vlisp_directory /*
3837 *Directory of core Lisp files that come with XEmacs.
3838 */ );
3839   Vlisp_directory = Qnil;
3840
3841   DEFVAR_LISP ("configure-lisp-directory", &Vconfigure_lisp_directory /*
3842 For internal use by the build procedure only.
3843 configure's idea of what `lisp-directory' will be.
3844 */ );
3845 #ifdef PATH_LOADSEARCH
3846   Vconfigure_lisp_directory = Ffile_name_as_directory
3847     (build_string ((char *) PATH_LOADSEARCH));
3848 #else
3849   Vconfigure_lisp_directory = Qnil;
3850 #endif
3851
3852   DEFVAR_LISP ("mule-lisp-directory", &Vmule_lisp_directory /*
3853 *Directory of Mule Lisp files that come with XEmacs.
3854 */ );
3855   Vmule_lisp_directory = Qnil;
3856
3857   DEFVAR_LISP ("configure-mule-lisp-directory", &Vconfigure_mule_lisp_directory /*
3858 For internal use by the build procedure only.
3859 configure's idea of what `mule-lisp-directory' will be.
3860 */ );
3861 #ifdef PATH_MULELOADSEARCH
3862   Vconfigure_mule_lisp_directory = Ffile_name_as_directory
3863     (build_string ((char *) PATH_MULELOADSEARCH));
3864 #else
3865   Vconfigure_mule_lisp_directory = Qnil;
3866 #endif
3867
3868   DEFVAR_LISP ("utf-2000-lisp-directory", &Vutf_2000_lisp_directory /*
3869 *Directory of UTF-2000 Lisp files that come with XEmacs.
3870 */ );
3871   Vutf_2000_lisp_directory = Qnil;
3872
3873   DEFVAR_LISP ("configure-utf-2000-lisp-directory",
3874                &Vconfigure_utf_2000_lisp_directory /*
3875 For internal use by the build procedure only.
3876 configure's idea of what `utf-2000-lisp-directory' will be.
3877 */ );
3878 #ifdef PATH_UTF2000LOADSEARCH
3879   Vconfigure_utf_2000_lisp_directory = Ffile_name_as_directory
3880     (build_string ((char *) PATH_UTF2000LOADSEARCH));
3881 #else
3882   Vconfigure_utf_2000_lisp_directory = Qnil;
3883 #endif
3884
3885   DEFVAR_LISP ("module-directory", &Vmodule_directory /*
3886 *Directory of core dynamic modules that come with XEmacs.
3887 */ );
3888   Vmodule_directory = Qnil;
3889
3890   DEFVAR_LISP ("configure-module-directory", &Vconfigure_module_directory /*
3891 For internal use by the build procedure only.
3892 configure's idea of what `module-directory' will be.
3893 */ );
3894 #ifdef PATH_MODULESEARCH
3895   Vconfigure_module_directory = Ffile_name_as_directory
3896     (build_string ((char *) PATH_MODULESEARCH));
3897 #else
3898   Vconfigure_module_directory = Qnil;
3899 #endif
3900
3901   DEFVAR_LISP ("configure-package-path", &Vconfigure_package_path /*
3902 For internal use by the build procedure only.
3903 configure's idea of what the package path will be.
3904 */ );
3905 #ifdef PATH_PACKAGEPATH
3906   Vconfigure_package_path = decode_path (PATH_PACKAGEPATH);
3907 #else
3908   Vconfigure_package_path = Qnil;
3909 #endif
3910
3911   DEFVAR_LISP ("data-directory", &Vdata_directory /*
3912 *Directory of architecture-independent files that come with XEmacs,
3913 intended for XEmacs to use.
3914 Use of this variable in new code is almost never correct.  See the
3915 functions `locate-data-file' and `locate-data-directory' and the variable
3916 `data-directory-list'.
3917 */ );
3918   Vdata_directory = Qnil;
3919
3920   DEFVAR_LISP ("configure-data-directory", &Vconfigure_data_directory /*
3921 For internal use by the build procedure only.
3922 configure's idea of what `data-directory' will be.
3923 */ );
3924 #ifdef PATH_DATA
3925   Vconfigure_data_directory = Ffile_name_as_directory
3926     (build_string ((char *) PATH_DATA));
3927 #else
3928   Vconfigure_data_directory = Qnil;
3929 #endif
3930
3931   DEFVAR_LISP ("data-directory-list", &Vdata_directory_list /*
3932 *List of directories of architecture-independent files that come with XEmacs
3933 or were installed as packages, and are intended for XEmacs to use.
3934 */ );
3935   Vdata_directory_list = Qnil;
3936
3937   DEFVAR_LISP ("site-directory", &Vsite_directory /*
3938 *Directory of site-specific Lisp files that come with XEmacs.
3939 */ );
3940   Vsite_directory = Qnil;
3941
3942   DEFVAR_LISP ("configure-site-directory", &Vconfigure_site_directory /*
3943 For internal use by the build procedure only.
3944 configure's idea of what `site-directory' will be.
3945 */ );
3946 #ifdef PATH_SITE
3947   Vconfigure_site_directory = Ffile_name_as_directory
3948     (build_string ((char *) PATH_SITE));
3949 #else
3950   Vconfigure_site_directory = Qnil;
3951 #endif
3952
3953   DEFVAR_LISP ("site-module-directory", &Vsite_module_directory /*
3954 *Directory of site-specific loadable modules that come with XEmacs.
3955 */ );
3956   Vsite_module_directory = Qnil;
3957
3958   DEFVAR_LISP ("configure-site-module-directory", &Vconfigure_site_module_directory /*
3959 For internal use by the build procedure only.
3960 configure's idea of what `site-directory' will be.
3961 */ );
3962 #ifdef PATH_SITE_MODULES
3963   Vconfigure_site_module_directory = Ffile_name_as_directory
3964     (build_string ((char *) PATH_SITE_MODULES));
3965 #else
3966   Vconfigure_site_module_directory = Qnil;
3967 #endif
3968
3969   DEFVAR_LISP ("doc-directory", &Vdoc_directory /*
3970 *Directory containing the DOC file that comes with XEmacs.
3971 This is usually the same as `exec-directory'.
3972 */ );
3973   Vdoc_directory = Qnil;
3974
3975   DEFVAR_LISP ("configure-doc-directory", &Vconfigure_doc_directory /*
3976 For internal use by the build procedure only.
3977 configure's idea of what `doc-directory' will be.
3978 */ );
3979 #ifdef PATH_DOC
3980   Vconfigure_doc_directory = Ffile_name_as_directory
3981     (build_string ((char *) PATH_DOC));
3982 #else
3983   Vconfigure_doc_directory = Qnil;
3984 #endif
3985
3986   DEFVAR_LISP ("configure-exec-prefix-directory", &Vconfigure_exec_prefix_directory /*
3987 For internal use by the build procedure only.
3988 configure's idea of what `exec-prefix-directory' will be.
3989 */ );
3990 #ifdef PATH_EXEC_PREFIX
3991   Vconfigure_exec_prefix_directory = Ffile_name_as_directory
3992     (build_string ((char *) PATH_EXEC_PREFIX));
3993 #else
3994   Vconfigure_exec_prefix_directory = Qnil;
3995 #endif
3996
3997   DEFVAR_LISP ("configure-prefix-directory", &Vconfigure_prefix_directory /*
3998 For internal use by the build procedure only.
3999 configure's idea of what `prefix-directory' will be.
4000 */ );
4001 #ifdef PATH_PREFIX
4002   Vconfigure_prefix_directory = Ffile_name_as_directory
4003     (build_string ((char *) PATH_PREFIX));
4004 #else
4005   Vconfigure_prefix_directory = Qnil;
4006 #endif
4007
4008   DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory /*
4009 For internal use by the build procedure only.
4010 This is the name of the directory in which the build procedure installed
4011 Emacs's info files; the default value for Info-default-directory-list
4012 includes this.
4013 */ );
4014 #ifdef PATH_INFO
4015   Vconfigure_info_directory =
4016     Ffile_name_as_directory (build_string (PATH_INFO));
4017 #else
4018   Vconfigure_info_directory = Qnil;
4019 #endif
4020
4021   DEFVAR_LISP ("configure-info-path", &Vconfigure_info_path /*
4022 The configured initial path for info documentation.
4023 */ );
4024 #ifdef PATH_INFOPATH
4025   Vconfigure_info_path = decode_path (PATH_INFOPATH);
4026 #else
4027   Vconfigure_info_path = Qnil;
4028 #endif
4029 }
4030
4031 #if defined(__sgi) && !defined(PDUMP)
4032 /* This is so tremendously ugly I'd puke. But then, it works.
4033  * The target is to override the static constructor from the
4034  * libiflPNG.so library which is masquerading as libz, and
4035  * cores on us when re-started from the dumped executable.
4036  * This will have to go for 21.1  -- OG.
4037  */
4038 void __sti__iflPNGFile_c___ (void);
4039 void
4040 __sti__iflPNGFile_c___ (void)
4041 {
4042 }
4043
4044 #endif