(U+37FD): Apply new conventions for glyph granularity for components
[chise/xemacs-chise.git.1] / 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,2010 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       /* This initializes data-sources of built-in genres */
2191 #ifdef HAVE_CONCORD
2192       complex_vars_of_concord ();
2193 #endif
2194
2195 #ifdef ERROR_CHECK_GC
2196       {
2197         extern int always_gc;
2198         if (always_gc)                /* purification debugging hack */
2199           garbage_collect_1 ();
2200       }
2201 #endif
2202 #ifdef PDUMP
2203     } else if (!restart) {            /* after successful pdump_load() */
2204       reinit_alloc_once_early ();
2205       reinit_symbols_once_early ();
2206       reinit_opaque_once_early ();
2207
2208       reinit_console_type_create_stream ();
2209 #ifdef HAVE_TTY
2210       reinit_console_type_create_tty ();
2211 #endif
2212 #ifdef HAVE_X_WINDOWS
2213       reinit_console_type_create_x ();
2214       reinit_console_type_create_device_x ();
2215 #endif
2216 #ifdef HAVE_MS_WINDOWS
2217       reinit_console_type_create_mswindows ();
2218 #endif
2219 #ifdef HAVE_GTK
2220       reinit_console_type_create_gtk ();
2221 #endif
2222
2223       reinit_specifier_type_create ();
2224       reinit_specifier_type_create_image ();
2225       reinit_specifier_type_create_gutter ();
2226       reinit_specifier_type_create_objects ();
2227 #ifdef HAVE_TOOLBARS
2228       reinit_specifier_type_create_toolbar ();
2229 #endif
2230
2231       structure_type_create ();
2232
2233       structure_type_create_chartab ();
2234       structure_type_create_faces ();
2235       structure_type_create_rangetab ();
2236       structure_type_create_hash_table ();
2237 #ifdef HAVE_CONCORD
2238       structure_type_create_concord ();
2239 #endif
2240
2241       lstream_type_create ();
2242 #ifdef FILE_CODING
2243       lstream_type_create_file_coding ();
2244 #endif
2245 #if defined (HAVE_MS_WINDOWS) && !defined(HAVE_MSG_SELECT)
2246       lstream_type_create_mswindows_selectable ();
2247 #endif
2248 #ifdef HAVE_UNIX_PROCESSES
2249       process_type_create_unix ();
2250 #endif
2251 #ifdef HAVE_WIN32_PROCESSES
2252       process_type_create_nt ();
2253 #endif
2254
2255       reinit_vars_of_buffer ();
2256       reinit_vars_of_console ();
2257 #ifdef DEBUG_XEMACS
2258       reinit_vars_of_debug ();
2259 #endif
2260       reinit_vars_of_device ();
2261       reinit_vars_of_eval ();
2262 #ifdef HAVE_X_WINDOWS
2263       reinit_vars_of_event_Xt ();
2264 #endif
2265 #ifdef HAVE_GTK
2266       reinit_vars_of_event_gtk ();
2267 #endif
2268 #if defined(HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS))
2269       reinit_vars_of_event_tty ();
2270 #endif
2271 #ifdef HAVE_MS_WINDOWS
2272       reinit_vars_of_event_mswindows ();
2273 #endif
2274       reinit_vars_of_event_stream ();
2275       reinit_vars_of_events ();
2276       reinit_vars_of_extents ();
2277       reinit_vars_of_fileio ();
2278       reinit_vars_of_font_lock ();
2279       reinit_vars_of_glyphs ();
2280       reinit_vars_of_glyphs_widget ();
2281       reinit_vars_of_insdel ();
2282       reinit_vars_of_lread ();
2283       reinit_vars_of_lstream ();
2284       reinit_vars_of_minibuf ();
2285 #ifdef HAVE_SHLIB
2286       reinit_vars_of_module ();
2287 #endif
2288       reinit_vars_of_objects ();
2289       reinit_vars_of_print ();
2290       reinit_vars_of_search ();
2291       reinit_vars_of_undo ();
2292       reinit_vars_of_window ();
2293
2294 #ifdef HAVE_MS_WINDOWS
2295       reinit_vars_of_frame_mswindows ();
2296 #endif
2297
2298 #ifdef HAVE_GTK
2299       reinit_vars_of_menubar_gtk ();
2300 #endif
2301
2302 #ifdef HAVE_X_WINDOWS
2303       reinit_vars_of_device_x ();
2304 #ifdef HAVE_SCROLLBARS
2305       reinit_vars_of_scrollbar_x ();
2306 #endif
2307 #ifdef HAVE_MENUBARS
2308       reinit_vars_of_menubar_x ();
2309 #endif
2310       reinit_vars_of_select_x ();
2311 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS)
2312       reinit_vars_of_gui_x ();
2313 #endif
2314 #endif /* HAVE_X_WINDOWS */
2315
2316 #if defined(MULE) && defined(HAVE_WNN)
2317       reinit_vars_of_mule_wnn ();
2318 #endif
2319
2320       reinit_complex_vars_of_buffer ();
2321       reinit_complex_vars_of_console ();
2322       reinit_complex_vars_of_minibuf ();
2323 #endif /* PDUMP */
2324     }
2325
2326
2327   /* CONGRATULATIONS!!!  We have successfully initialized the Lisp
2328      engine. */
2329
2330   if (initialized)
2331     {
2332       /* Stuff that should not be done at dump time, including stuff that
2333          needs to be reset at run time.  Order below should not matter.
2334
2335          Many initializations taken from the environment should go here. */
2336       reinit_alloc ();
2337       reinit_eval ();
2338 #ifdef MULE_REGEXP
2339       reinit_mule_category ();
2340 #endif
2341 #ifdef HAVE_POSTGRESQL
2342       init_postgresql_from_environment();
2343 #endif
2344     }
2345
2346   /* Now do further initialization/setup of stuff that is not needed by the
2347      syms_of_() routines.  This involves stuff that only is enabled in
2348      an interactive run (redisplay, user input, etc.) and stuff that is
2349      not needed until we start loading Lisp code (the reader).  A lot
2350      of this stuff involves querying the current environment and needs
2351      to be done both at dump time and at run time. */
2352
2353   init_initial_directory();             /* get the directory to use for the
2354                                            "*scratch*" buffer, etc. */
2355
2356 #ifdef WIN32_NATIVE
2357   /*
2358    * For Win32, call init_environment() now, so that environment/registry
2359    * variables will be properly entered into Vprocess_environment.
2360    */
2361   init_environment();
2362 #endif
2363
2364   init_callproc ();     /* Set up the process environment (so that egetenv
2365                            works), the basic directory variables
2366                            (exec-directory and so on), and stuff
2367                            related to subprocesses.  This should be
2368                            first because many of the functions below
2369                            call egetenv() to get environment variables. */
2370   init_lread ();        /* Set up the Lisp reader. */
2371   init_cmdargs (argc, (Extbyte **) argv,
2372                 skip_args);     /* Create list Vcommand_line_args */
2373   init_buffer ();       /* Set default directory of *scratch* buffer */
2374
2375 #ifdef WIN32_NATIVE
2376   init_ntproc();
2377 #endif
2378
2379   init_redisplay ();      /* Determine terminal type.
2380                              init_sys_modes uses results */
2381   init_frame ();
2382   init_event_stream (); /* Set up so we can get user input. */
2383   init_macros (); /* set up so we can run macros. */
2384   init_editfns (); /* Determine the name of the user we're running as */
2385   init_xemacs_process (); /* set up for calling subprocesses */
2386 #ifdef SUNPRO
2387   init_sunpro (); /* Set up Sunpro usage tracking */
2388 #endif
2389 #if defined (WIN32_NATIVE) || defined (CYGWIN)
2390   init_win32 ();
2391 #endif
2392 #if defined (HAVE_NATIVE_SOUND) && defined (hp9000s800)
2393   init_hpplay ();
2394 #endif
2395 #ifdef HAVE_TTY
2396   init_device_tty ();
2397 #endif
2398   init_console_stream (restart); /* Create the first console */
2399
2400   /* try to get the actual pathname of the exec file we are running */
2401   if (!restart)
2402   {
2403     Vinvocation_name = Fcar (Vcommand_line_args);
2404     if (XSTRING_DATA(Vinvocation_name)[0] == '-')
2405       {
2406         /* XEmacs as a login shell, oh goody! */
2407         Vinvocation_name = build_string(getenv("SHELL"));
2408       }
2409     Vinvocation_directory = Vinvocation_name;
2410
2411     if (!NILP (Ffile_name_directory (Vinvocation_name)))
2412       {
2413         /* invocation-name includes a directory component -- presumably it
2414            is relative to cwd, not $PATH */
2415         Vinvocation_directory = Fexpand_file_name (Vinvocation_name,
2416                                                    Qnil);
2417         Vinvocation_path = Qnil;
2418       }
2419     else
2420       {
2421         Vinvocation_path = decode_env_path ("PATH", NULL);
2422         locate_file (Vinvocation_path, Vinvocation_name,
2423                      Vlisp_EXEC_SUFFIXES,
2424                      &Vinvocation_directory, X_OK);
2425       }
2426
2427     if (NILP (Vinvocation_directory))
2428       Vinvocation_directory = Vinvocation_name;
2429
2430     Vinvocation_name = Ffile_name_nondirectory (Vinvocation_directory);
2431     Vinvocation_directory = Ffile_name_directory (Vinvocation_directory);
2432   }
2433
2434 #if defined(HAVE_SHLIB) && !defined(WIN32_NATIVE)
2435   /* This is Unix only.  MS Windows NT has a library call that does
2436      The Right Thing on that system.  Rumor has it, this must be
2437      called for GNU dld in temacs and xemacs.  */
2438   {
2439     char *buf = (char *)alloca (XSTRING_LENGTH (Vinvocation_directory)
2440                                 + XSTRING_LENGTH (Vinvocation_name)
2441                                 + 2);
2442     sprintf (buf, "%s/%s", XSTRING_DATA (Vinvocation_directory),
2443              XSTRING_DATA (Vinvocation_name));
2444
2445     /* All we can do is cry if an error happens, so ignore it. */
2446     (void) dll_init (buf);
2447   }
2448 #endif
2449
2450 #if defined (LOCALTIME_CACHE) && defined (HAVE_TZSET)
2451   /* sun's localtime() has a bug.  it caches the value of the time
2452      zone rather than looking it up every time.  Since localtime() is
2453      called to bolt the undumping time into the undumped emacs, this
2454      results in localtime() ignoring the TZ environment variable.
2455      This flushes the new TZ value into localtime(). */
2456   tzset ();
2457 #endif /* LOCALTIME_CACHE and TZSET */
2458
2459   load_me = Qnil;
2460   if (!initialized)
2461     {
2462       /* Handle -l loadup-and-dump, args passed by Makefile. */
2463       if (argc > 2 + skip_args && !strcmp (argv[1 + skip_args], "-l"))
2464         load_me = build_string (argv[2 + skip_args]);
2465 #if 0 /* CANNOT_DUMP - this can never be right in XEmacs --andyp */
2466       /* Unless next switch is -nl, load "loadup.el" first thing.  */
2467       if (!(argc > 1 + skip_args && !strcmp (argv[1 + skip_args], "-nl")))
2468         load_me = build_string ("loadup.el");
2469 #endif /* CANNOT_DUMP */
2470     }
2471
2472 #ifdef QUANTIFY
2473   if (initialized)
2474     quantify_start_recording_data ();
2475 #endif /* QUANTIFY */
2476
2477   initialized = 1;
2478   inhibit_non_essential_printing_operations = 0;
2479
2480   /* This never returns.  */
2481   initial_command_loop (load_me);
2482   /* NOTREACHED */
2483 }
2484
2485 \f
2486 /* Sort the args so we can find the most important ones
2487    at the beginning of argv.  */
2488
2489 /* First, here's a table of all the standard options.  */
2490
2491 struct standard_args
2492 {
2493   const char *name;
2494   const char *longname;
2495   int priority;
2496   int nargs;
2497 };
2498
2499 static const struct standard_args standard_args[] =
2500 {
2501   /* Handled by main_1 above: */
2502   { "-sd", "--show-dump-id", 105, 0 },
2503   { "-t", "--terminal", 100, 1 },
2504   { "-nd", "--no-dump-file", 95, 0 },
2505   { "-nw", "--no-windows", 90, 0 },
2506   { "-batch", "--batch", 85, 0 },
2507   { "-debug-paths", "--debug-paths", 82, 0 },
2508   { "-help", "--help", 80, 0 },
2509   { "-version", "--version", 75, 0 },
2510   { "-V", 0, 75, 0 },
2511   { "-d", "--display", 80, 1 },
2512   { "-display", 0, 80, 1 },
2513   { "-NXHost",  0, 79, 0 },
2514   { "-MachLaunch", 0, 79, 0},
2515
2516   /* Handled by command-line-early in startup.el: */
2517   { "-q", "--no-init-file", 50, 0 },
2518   { "-unmapped", 0, 50, 0 },
2519   { "-no-init-file", 0, 50, 0 },
2520   { "-vanilla", "--vanilla", 50, 0 },
2521   { "-no-autoloads", "--no-autoloads", 50, 0 },
2522   { "-no-site-file", "--no-site-file", 40, 0 },
2523   { "-no-early-packages", "--no-early-packages", 35, 0 },
2524   { "-u", "--user", 30, 1 },
2525   { "-user", 0, 30, 1 },
2526   { "-debug-init", "--debug-init", 20, 0 },
2527   { "-debug-paths", "--debug-paths", 20, 0 },
2528
2529   /* Xt options: */
2530   { "-i", "--icon-type", 15, 0 },
2531   { "-itype", 0, 15, 0 },
2532   { "-iconic", "--iconic", 15, 0 },
2533   { "-bg", "--background-color", 10, 1 },
2534   { "-background", 0, 10, 1 },
2535   { "-fg", "--foreground-color", 10, 1 },
2536   { "-foreground", 0, 10, 1 },
2537   { "-bd", "--border-color", 10, 1 },
2538   { "-bw", "--border-width", 10, 1 },
2539   { "-ib", "--internal-border", 10, 1 },
2540   { "-ms", "--mouse-color", 10, 1 },
2541   { "-cr", "--cursor-color", 10, 1 },
2542   { "-fn", "--font", 10, 1 },
2543   { "-font", 0, 10, 1 },
2544   { "-g", "--geometry", 10, 1 },
2545   { "-geometry", 0, 10, 1 },
2546   { "-T", "--title", 10, 1 },
2547   { "-title", 0, 10, 1 },
2548   { "-name", "--name", 10, 1 },
2549   { "-xrm", "--xrm", 10, 1 },
2550   { "-r", "--reverse-video", 5, 0 },
2551   { "-rv", 0, 5, 0 },
2552   { "-reverse", 0, 5, 0 },
2553   { "-hb", "--horizontal-scroll-bars", 5, 0 },
2554   { "-vb", "--vertical-scroll-bars", 5, 0 },
2555
2556   /* These have the same priority as ordinary file name args,
2557      so they are not reordered with respect to those.  */
2558   { "-L", "--directory", 0, 1 },
2559   { "-directory", 0, 0, 1 },
2560   { "-l", "--load", 0, 1 },
2561   { "-load", 0, 0, 1 },
2562   { "-f", "--funcall", 0, 1 },
2563   { "-funcall", 0, 0, 1 },
2564   { "-eval", "--eval", 0, 1 },
2565   { "-insert", "--insert", 0, 1 },
2566   /* This should be processed after ordinary file name args and the like.  */
2567   { "-kill", "--kill", -10, 0 },
2568 };
2569
2570 /* Reorder the elements of ARGV (assumed to have ARGC elements)
2571    so that the highest priority ones come first.
2572    Do not change the order of elements of equal priority.
2573    If an option takes an argument, keep it and its argument together.  */
2574
2575 static void
2576 sort_args (int argc, char **argv)
2577 {
2578   char **new_argv = xnew_array (char *, argc);
2579   /* For each element of argv,
2580      the corresponding element of options is:
2581      0 for an option that takes no arguments,
2582      1 for an option that takes one argument, etc.
2583      -1 for an ordinary non-option argument.  */
2584   int *options  = xnew_array (int, argc);
2585   int *priority = xnew_array (int, argc);
2586   int to = 1;
2587   int from;
2588   int i;
2589   int end_of_options_p = 0;
2590
2591   /* Categorize all the options,
2592      and figure out which argv elts are option arguments.  */
2593   for (from = 1; from < argc; from++)
2594     {
2595       options[from] = -1;
2596       priority[from] = 0;
2597       /* Pseudo options "--" and "run-temacs" indicate end of options */
2598       if (!strcmp (argv[from], "--") ||
2599           !strcmp (argv[from], "run-temacs"))
2600         end_of_options_p = 1;
2601       if (!end_of_options_p && argv[from][0] == '-')
2602         {
2603           int match, thislen;
2604           char *equals;
2605
2606           /* Look for a match with a known old-fashioned option.  */
2607           for (i = 0; i < countof (standard_args); i++)
2608             if (!strcmp (argv[from], standard_args[i].name))
2609               {
2610                 options[from]  = standard_args[i].nargs;
2611                 priority[from] = standard_args[i].priority;
2612                 if (from + standard_args[i].nargs >= argc)
2613                   fatal ("Option `%s' requires an argument\n", argv[from]);
2614                 from += standard_args[i].nargs;
2615                 goto done;
2616               }
2617
2618           /* Look for a match with a known long option.
2619              MATCH is -1 if no match so far, -2 if two or more matches so far,
2620              >= 0 (the table index of the match) if just one match so far.  */
2621           if (argv[from][1] == '-')
2622             {
2623               match = -1;
2624               thislen = strlen (argv[from]);
2625               equals = strchr (argv[from], '=');
2626               if (equals != 0)
2627                 thislen = equals - argv[from];
2628
2629               for (i = 0; i < countof (standard_args); i++)
2630                 if (standard_args[i].longname
2631                     && !strncmp (argv[from], standard_args[i].longname,
2632                                  thislen))
2633                   {
2634                     if (match == -1)
2635                       match = i;
2636                     else
2637                       match = -2;
2638                   }
2639
2640               /* If we found exactly one match, use that.  */
2641               if (match >= 0)
2642                 {
2643                   options[from]  = standard_args[match].nargs;
2644                   priority[from] = standard_args[match].priority;
2645                   /* If --OPTION=VALUE syntax is used,
2646                      this option uses just one argv element.  */
2647                   if (equals != 0)
2648                     options[from] = 0;
2649                   if (from + options[from] >= argc)
2650                     fatal ("Option `%s' requires an argument\n", argv[from]);
2651                   from += options[from];
2652                 }
2653             }
2654         done: ;
2655         }
2656     }
2657
2658   /* Copy the arguments, in order of decreasing priority, to NEW_ARGV.  */
2659   new_argv[0] = argv[0];
2660   while (to < argc)
2661     {
2662       int best = -1;
2663       int best_priority = -9999;
2664
2665       /* Find the highest priority remaining option.
2666          If several have equal priority, take the first of them.  */
2667       for (from = 1; from < argc; from++)
2668         {
2669           if (argv[from] != 0 && priority[from] > best_priority)
2670             {
2671               best_priority = priority[from];
2672               best = from;
2673             }
2674           /* Skip option arguments--they are tied to the options.  */
2675           if (options[from] > 0)
2676             from += options[from];
2677         }
2678
2679       if (best < 0)
2680         ABORT ();
2681
2682       /* Copy the highest priority remaining option, with its args, to NEW_ARGV.  */
2683       new_argv[to++] = argv[best];
2684       for (i = 0; i < options[best]; i++)
2685         new_argv[to++] = argv[best + i + 1];
2686
2687       /* Clear out this option in ARGV.  */
2688       argv[best] = 0;
2689       for (i = 0; i < options[best]; i++)
2690         argv[best + i + 1] = 0;
2691     }
2692
2693   memcpy (argv, new_argv, sizeof (char *) * argc);
2694   xfree (new_argv);
2695   xfree (options);
2696   xfree (priority);
2697 }
2698
2699 DEFUN ("running-temacs-p", Frunning_temacs_p, 0, 0, 0, /*
2700 True if running temacs.  This means we are in the dumping stage.
2701 This is false during normal execution of the `xemacs' program, and
2702 becomes false once `run-emacs-from-temacs' is run.
2703 */
2704        ())
2705 {
2706   return run_temacs_argc >= 0 ? Qt : Qnil;
2707 }
2708
2709 DEFUN ("run-emacs-from-temacs", Frun_emacs_from_temacs, 0, MANY, 0, /*
2710 Do not call this.  It will reinitialize your XEmacs.  You'll be sorry.
2711 */
2712 /* If this function is called from startup.el, it will be possible to run
2713    temacs as an editor using 'temacs -batch -l loadup.el run-temacs', instead
2714    of having to dump an emacs and then run that (when debugging emacs itself,
2715    this can be much faster)). [Actually, the speed difference isn't that
2716    much as long as your filesystem is local, and you don't end up with
2717    a dumped version in case you want to rerun it.  This function is most
2718    useful when used as part of the `make all-elc' command. --ben]
2719    This will "restart" emacs with the specified command-line arguments.
2720
2721    Martin thinks this function is most useful when using debugging
2722    tools like Purify or tcov that get confused by XEmacs' dumping.  */
2723      (int nargs, Lisp_Object *args))
2724 {
2725   int ac;
2726   const Extbyte *wampum;
2727   int namesize;
2728   int total_len;
2729   Lisp_Object orig_invoc_name = Fcar (Vcommand_line_args);
2730   const Extbyte **wampum_all = alloca_array (const Extbyte *, nargs);
2731   int *wampum_all_len  = alloca_array (int, nargs);
2732
2733   assert (!gc_in_progress);
2734
2735   if (run_temacs_argc < 0)
2736     error ("I've lost my temacs-hood.");
2737
2738   /* Need to convert the orig_invoc_name and all of the arguments
2739      to external format. */
2740
2741   TO_EXTERNAL_FORMAT (LISP_STRING, orig_invoc_name,
2742                       ALLOCA, (wampum, namesize),
2743                       Qnative);
2744   namesize++;
2745
2746   for (ac = 0, total_len = namesize; ac < nargs; ac++)
2747     {
2748       CHECK_STRING (args[ac]);
2749       TO_EXTERNAL_FORMAT (LISP_STRING, args[ac],
2750                           ALLOCA, (wampum_all[ac], wampum_all_len[ac]),
2751                           Qnative);
2752       wampum_all_len[ac]++;
2753       total_len += wampum_all_len[ac];
2754     }
2755   DO_REALLOC (run_temacs_args, run_temacs_args_size, total_len, char);
2756   DO_REALLOC (run_temacs_argv, run_temacs_argv_size, nargs+2, char *);
2757
2758   memcpy (run_temacs_args, wampum, namesize);
2759   run_temacs_argv [0] = run_temacs_args;
2760   for (ac = 0; ac < nargs; ac++)
2761     {
2762       memcpy (run_temacs_args + namesize,
2763               wampum_all[ac], wampum_all_len[ac]);
2764       run_temacs_argv [ac + 1] = run_temacs_args + namesize;
2765       namesize += wampum_all_len[ac];
2766     }
2767   run_temacs_argv [nargs + 1] = 0;
2768   catchlist = NULL; /* Important!  Otherwise free_cons() calls in
2769                        condition_case_unwind() may lead to GC death. */
2770   unbind_to (0, Qnil); /* this closes loadup.el */
2771   purify_flag = 0;
2772   run_temacs_argc = nargs + 1;
2773 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
2774   report_sheap_usage (0);
2775 #endif
2776   LONGJMP (run_temacs_catch, 1);
2777   return Qnil; /* not reached; warning suppression */
2778 }
2779
2780 /* ARGSUSED */
2781 int
2782 main (int argc, char **argv, char **envp)
2783 {
2784
2785 #ifdef _MSC_VER
2786   /* Under VC++, access violations and the like are not sent through
2787      the standard signal() mechanism.  Rather, they need to be handled
2788      using the Microsoft "structured exception handling" mechanism,
2789      which vaguely resembles the C++ mechanisms. */
2790   __try
2791   {
2792 #endif
2793
2794   int     volatile vol_argc = argc;
2795   char ** volatile vol_argv = argv;
2796   char ** volatile vol_envp = envp;
2797   /* This is hairy.  We need to compute where the XEmacs binary was invoked
2798      from because temacs initialization requires it to find the lisp
2799      directories.  The code that recomputes the path is guarded by the
2800      restarted flag.  There are three possible paths I've found so far
2801      through this:
2802
2803      temacs -- When running temacs for basic build stuff, the first main_1
2804       will be the only one invoked.  It must compute the path else there
2805       will be a very ugly bomb in startup.el (can't find obvious location
2806       for doc-directory data-directory, etc.).
2807
2808      temacs w/ run-temacs on the command line -- This is run to bytecompile
2809       all the out of date dumped lisp.  It will execute both of the main_1
2810       calls and the second one must not touch the first computation because
2811       argc/argv are hosed the second time through.
2812
2813      xemacs -- Only the second main_1 is executed.  The invocation path must
2814       computed but this only matters when running in place or when running
2815       as a login shell.
2816
2817      As a bonus for straightening this out, XEmacs can now be run in place
2818      as a login shell.  This never used to work.
2819
2820      As another bonus, we can now guarantee that
2821      (concat invocation-directory invocation-name) contains the filename
2822      of the XEmacs binary we are running.  This can now be used in a
2823      definite test for out of date dumped files.  -slb */
2824   int restarted = 0;
2825 #ifdef QUANTIFY
2826   quantify_stop_recording_data ();
2827   quantify_clear_data ();
2828 #endif /* QUANTIFY */
2829
2830   inhibit_non_essential_printing_operations = 1;
2831   suppress_early_error_handler_backtrace = 0;
2832   lim_data = 0; /* force reinitialization of this variable */
2833
2834   /* Lisp_Object must fit in a word; check VALBITS and GCTYPEBITS */
2835   assert (sizeof (Lisp_Object) == sizeof (void *));
2836
2837 #ifdef LINUX_SBRK_BUG
2838   sbrk (1);
2839 #endif
2840
2841   if (!initialized)
2842     {
2843 #ifdef DOUG_LEA_MALLOC
2844       if (mallopt (M_MMAP_MAX, 0) != 1)
2845         ABORT();
2846 #endif
2847       run_temacs_argc = 0;
2848       if (! SETJMP (run_temacs_catch))
2849         {
2850           main_1 (vol_argc, vol_argv, vol_envp, 0);
2851         }
2852       /* run-emacs-from-temacs called */
2853       restarted = 1;
2854       vol_argc = run_temacs_argc;
2855       vol_argv = run_temacs_argv;
2856 #ifdef _SCO_DS
2857       /* This makes absolutely no sense to anyone involved.  There are
2858          several people using this stuff.  We've compared versions on
2859          everything we can think of.  We can find no difference.
2860          However, on both my systems environ is a plain old global
2861          variable initialized to zero.  _environ is the one that
2862          contains pointers to the actual environment.
2863
2864          Since we can't figure out the difference (and we're hours
2865          away from a release), this takes a very cowardly approach and
2866          is bracketed with both a system specific preprocessor test
2867          and a runtime "do you have this problem" test
2868
2869          06/20/96 robertl@dgii.com */
2870       {
2871         extern char **_environ;
2872         if ((unsigned) environ == 0)
2873           environ=_environ;
2874       }
2875 #endif /* _SCO_DS */
2876       vol_envp = environ;
2877     }
2878 #if defined (RUN_TIME_REMAP) && ! defined (PDUMP)
2879   else
2880     /* obviously no-one uses this because where it was before initialized was
2881      *always* true */
2882     run_time_remap (argv[0]);
2883 #endif
2884
2885 #ifdef DOUG_LEA_MALLOC
2886   if (initialized && (malloc_state_ptr != NULL))
2887     {
2888       int rc = malloc_set_state (malloc_state_ptr);
2889       if (rc != 0)
2890         {
2891           stderr_out ("malloc_set_state failed, rc = %d\n", rc);
2892           ABORT ();
2893         }
2894 #if 0
2895       free (malloc_state_ptr);
2896 #endif
2897       /* mmap works in glibc-2.1, glibc-2.0 (Non-Mule only) and Linux libc5 */
2898 #if (defined(__GLIBC__) && __GLIBC_MINOR__ >= 1) || \
2899     defined(_NO_MALLOC_WARNING_) || \
2900     (defined(__GLIBC__) && __GLIBC_MINOR__ < 1 && !defined(MULE)) || \
2901     defined(DEBUG_DOUG_LEA_MALLOC)
2902       if(mallopt (M_MMAP_MAX, 0) != 1)
2903         ABORT();
2904 #endif
2905 #ifdef REL_ALLOC
2906       r_alloc_reinit ();
2907 #endif
2908     }
2909 #endif /* DOUG_LEA_MALLOC */
2910
2911   run_temacs_argc = -1;
2912
2913   main_1 (vol_argc, vol_argv, vol_envp, restarted);
2914
2915 #ifdef _MSC_VER
2916   }
2917   /* VC++ documentation says that
2918      GetExceptionCode() cannot be called inside the filter itself. */
2919   __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {}
2920 #endif
2921
2922   return 0; /* unreached */
2923 }
2924
2925 \f
2926 /* Dumping apparently isn't supported by versions of GCC >= 2.8. */
2927 /* The following needs conditionalization on whether either XEmacs or */
2928 /* various system shared libraries have been built and linked with */
2929 /* GCC >= 2.8.  -slb */
2930 #if defined(GNU_MALLOC)
2931 static void
2932 voodoo_free_hook (void *mem)
2933 {
2934   /* Disable all calls to free() when XEmacs is exiting and it doesn't */
2935   /* matter. */
2936   __free_hook =
2937 #if defined __GNUC__ || defined __INTEL_COMPILER
2938 /* prototype of __free_hook varies with glibc version */
2939     (__typeof__ (__free_hook))
2940 #endif
2941     voodoo_free_hook;
2942 }
2943 #endif /* GNU_MALLOC */
2944
2945 DEFUN ("kill-emacs", Fkill_emacs, 0, 1, "P", /*
2946 Exit the XEmacs job and kill it.  Ask for confirmation, without argument.
2947 If ARG is an integer, return ARG as the exit program code.
2948 If ARG is a string, stuff it as keyboard input.
2949
2950 The value of `kill-emacs-hook', if not void,
2951 is a list of functions (of no args),
2952 all of which are called before XEmacs is actually killed.
2953 */
2954        (arg))
2955 {
2956   /* This function can GC */
2957   struct gcpro gcpro1;
2958
2959   GCPRO1 (arg);
2960
2961   if (feof (stdin))
2962     arg = Qt;
2963
2964   if (!preparing_for_armageddon && !noninteractive)
2965     run_hook (Qkill_emacs_hook);
2966
2967   ensure_no_quitting_from_now_on ();
2968
2969   if (!preparing_for_armageddon)
2970     {
2971       Lisp_Object concons, nextcons;
2972
2973       /* Normally, go ahead and delete all the consoles now.
2974          Some unmentionably lame window systems (MS Wwwww...... eek,
2975          I can't even say it) don't properly clean up after themselves,
2976          and even for those that do, it might be cleaner this way.
2977          If we're going down, however, we don't do this (might
2978          be too dangerous), and if we get a crash somewhere within
2979          this loop, we'll still autosave and won't try this again. */
2980
2981       LIST_LOOP_DELETING (concons, nextcons, Vconsole_list)
2982         {
2983           /* There is very little point in deleting the stream console.
2984              It uses stdio, which should flush any buffered output and
2985              something can only go wrong. -slb */
2986           /* I changed my mind.  There's a stupid hack in close to add
2987              a trailing newline. */
2988           /*if (!CONSOLE_STREAM_P (XCONSOLE (XCAR (concons))))*/
2989             delete_console_internal (XCONSOLE (XCAR (concons)), 1, 1, 0);
2990         }
2991     }
2992
2993   UNGCPRO;
2994
2995 #ifdef HAVE_MS_WINDOWS
2996   /* If we displayed a message on the console, then we must allow the
2997      user to see this message.  This may be unnecessary, but can't
2998      hurt, and we can't necessarily check arg; e.g. xemacs --help
2999      kills with argument 0.
3000
3001      Don't do this in batch mode, it makes no sense and is more
3002      annoying than useful. --andyp */
3003   if (mswindows_message_outputted && !noninteractive)
3004     Fmswindows_message_box (build_string ("Messages outputted.  XEmacs is exiting."),
3005                             Qnil, Qnil);
3006 #endif
3007
3008   shut_down_emacs (0, STRINGP (arg) ? arg : Qnil, 0);
3009
3010 #if defined(GNU_MALLOC)
3011   __free_hook =
3012 #if defined __GNUC__ || defined __INTEL_COMPILER
3013 /* prototype of __free_hook varies with glibc version */
3014     (__typeof__ (__free_hook))
3015 #endif
3016     voodoo_free_hook;
3017 #endif
3018
3019   exit (INTP (arg) ? XINT (arg) : 0);
3020   /* NOTREACHED */
3021   return Qnil; /* I'm sick of the compiler warning */
3022 }
3023
3024 /* Perform an orderly shutdown of XEmacs.  Autosave any modified
3025    buffers, kill any child processes, clean up the terminal modes (if
3026    we're in the foreground), and other stuff like that.  Don't perform
3027    any redisplay; this may be called when XEmacs is shutting down in
3028    the background, or after its X connection has died.
3029
3030    If SIG is a signal number, print a message for it.
3031
3032    This is called by fatal signal handlers and Fkill_emacs.  It used to
3033    be called by X protocol error handlers, but instead they now call
3034    Fkill_emacs. */
3035 static void
3036 shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save)
3037 {
3038   /* This function can GC */
3039   /* Prevent running of hooks and other non-essential stuff
3040      from now on.  */
3041   preparing_for_armageddon = 1;
3042
3043   ensure_no_quitting_from_now_on ();
3044
3045 #ifdef QUANTIFY
3046   quantify_stop_recording_data ();
3047 #endif /* QUANTIFY */
3048
3049   /* This is absolutely the most important thing to do, so make sure
3050      we do it now, before anything else.  We might have crashed and
3051      be in a weird inconsistent state, and potentially anything could
3052      set off another protection fault and cause us to bail out
3053      immediately. */
3054   /* Steve writes the following:
3055
3056      [[I'm not removing the code entirely, yet.  We have run up against
3057      a spate of problems in diagnosing crashes due to crashes within
3058      crashes.  It has very definitely been determined that code called
3059      during auto-saving cannot work if XEmacs crashed inside of GC.
3060      We already auto-save on an itimer so there cannot be too much
3061      unsaved stuff around, and if we get better crash reports we might
3062      be able to get more problems fixed so I'm disabling this.  -slb]]
3063
3064      and DISABLES AUTO-SAVING ENTIRELY during crashes!  Way way bad idea.
3065
3066      Instead let's just be more intelligent about avoiding crashing
3067      when possible, esp. nested crashes.
3068   */
3069   if (!no_auto_save)
3070     Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */
3071
3072   fflush (stdout);
3073   reset_all_consoles ();
3074   if (sig && sig != SIGTERM)
3075     {
3076       if (sig == -1)
3077         stderr_out ("\nFatal error.\n\n");
3078       else
3079         stderr_out ("\nFatal error (%d).\n\n", sig);
3080       stderr_out
3081         ("Your files have been auto-saved.\n"
3082          "Use `M-x recover-session' to recover them.\n"
3083          "\n"
3084          "Your version of XEmacs was distributed with a PROBLEMS file that  may describe\n"
3085          "your crash, and with luck a workaround.  Please check it first, but do report\n"
3086          "the crash anyway.  "
3087 #ifdef INFODOCK
3088          "\n\nPlease report this bug by selecting `Report-Bug' in the InfoDock menu.\n"
3089          "*BE SURE* to include the XEmacs configuration from M-x describe-installation,\n"
3090          "or the file Installation in the top directory of the build tree.\n"
3091 #else
3092          "Please report this bug by invoking M-x report-emacs-bug,\n"
3093          "or by selecting `Send Bug Report' from the Help menu.  If necessary, send\n"
3094          "ordinary email to `xemacs-beta@xemacs.org'.  *MAKE SURE* to include the XEmacs\n"
3095          "configuration from M-x describe-installation, or equivalently the file\n"
3096          "Installation in the top of the build tree.\n"
3097 #endif
3098 #ifndef _MSC_VER
3099          "\n"
3100          "*Please* try *hard* to obtain a C stack backtrace; without it, we are unlikely\n"
3101          "to be able to analyze the problem.  Locate the core file produced as a result\n"
3102          "of this crash (often called `core' or `core.<process-id>', and located in\n"
3103          "the directory in which you started XEmacs or your home directory), and type\n"
3104          "\n"
3105          "  gdb "
3106 #endif
3107          );
3108 #ifndef _MSC_VER
3109       {
3110         const char *name;
3111         char *dir = 0;
3112
3113         /* Now try to determine the actual path to the executable,
3114            to try to make the backtrace-determination process as foolproof
3115            as possible. */
3116         if (STRINGP (Vinvocation_name))
3117           name = (char *) XSTRING_DATA (Vinvocation_name);
3118         else
3119           name = "xemacs";
3120         if (STRINGP (Vinvocation_directory))
3121           dir = (char *) XSTRING_DATA (Vinvocation_directory);
3122         if (!dir || dir[0] != '/')
3123           stderr_out ("`which %s`", name);
3124         else if (dir[strlen (dir) - 1] != '/')
3125           stderr_out ("%s/%s", dir, name);
3126         else
3127           stderr_out ("%s%s", dir, name);
3128       }
3129       stderr_out
3130         (" core\n"
3131          "\n"
3132          "then type `where' at the debugger prompt.  No GDB on your system?  You may\n"
3133          "have DBX, or XDB, or SDB.  (Ask your system administrator if you need help.)\n"
3134          "If no core file was produced, enable them (often with `ulimit -c unlimited'\n"
3135          "in case of future recurrance of the crash.\n");
3136 #endif /* _MSC_VER */
3137     }
3138
3139   stuff_buffered_input (stuff);
3140
3141   kill_buffer_processes (Qnil);
3142
3143 #ifdef CLASH_DETECTION
3144   unlock_all_files ();
3145 #endif
3146
3147 #ifdef TOOLTALK
3148   tt_session_quit (tt_default_session ());
3149 #if 0
3150   /* The following crashes when built on X11R5 and run on X11R6 */
3151   tt_close ();
3152 #endif
3153 #endif /* TOOLTALK */
3154
3155 }
3156
3157 \f
3158 #ifndef CANNOT_DUMP
3159
3160 #if !defined(PDUMP) || !defined(SYSTEM_MALLOC)
3161 extern char my_edata[];
3162 #endif
3163
3164 extern void disable_free_hook (void);
3165
3166 DEFUN ("dump-emacs", Fdump_emacs, 2, 2, 0, /*
3167 Dump current state of XEmacs into executable file FILENAME.
3168 Take symbols from SYMFILE (presumably the file you executed to run XEmacs).
3169 This is used in the file `loadup.el' when building XEmacs.
3170
3171 Remember to set `command-line-processed' to nil before dumping
3172 if you want the dumped XEmacs to process its command line
3173 and announce itself normally when it is run.
3174 */
3175        (filename, symfile))
3176 {
3177   /* This function can GC */
3178   struct gcpro gcpro1, gcpro2;
3179   int opurify;
3180
3181   GCPRO2 (filename, symfile);
3182
3183 #ifdef FREE_CHECKING
3184   Freally_free (Qnil);
3185
3186   /* When we're dumping, we can't use the debugging free() */
3187   disable_free_hook ();
3188 #endif
3189
3190   CHECK_STRING (filename);
3191   filename = Fexpand_file_name (filename, Qnil);
3192   if (!NILP (symfile))
3193     {
3194       CHECK_STRING (symfile);
3195       if (XSTRING_LENGTH (symfile) > 0)
3196         symfile = Fexpand_file_name (symfile, Qnil);
3197       else
3198         symfile = Qnil;
3199     }
3200
3201   opurify = purify_flag;
3202   purify_flag = 0;
3203
3204 #if defined (HEAP_IN_DATA) && !defined(PDUMP)
3205   report_sheap_usage (1);
3206 #endif
3207
3208   clear_message ();
3209
3210   fflush (stderr);
3211   fflush (stdout);
3212
3213   disksave_object_finalization ();
3214   release_breathing_space ();
3215
3216   /* Tell malloc where start of impure now is */
3217   /* Also arrange for warnings when nearly out of space.  */
3218 #ifndef SYSTEM_MALLOC
3219   memory_warnings (my_edata, malloc_warning);
3220 #endif
3221
3222   UNGCPRO;
3223
3224   {
3225     char *filename_ext;
3226     char *symfile_ext;
3227
3228     LISP_STRING_TO_EXTERNAL (filename, filename_ext, Qfile_name);
3229
3230     if (STRINGP (symfile))
3231       LISP_STRING_TO_EXTERNAL (symfile, symfile_ext, Qfile_name);
3232     else
3233       symfile_ext = 0;
3234
3235     garbage_collect_1 ();
3236
3237 #ifdef PDUMP
3238     pdump ();
3239 #else
3240
3241 #ifdef DOUG_LEA_MALLOC
3242     malloc_state_ptr = malloc_get_state ();
3243 #endif
3244   /* here we break our rule that the filename conversion should
3245      be performed at the actual time that the system call is made.
3246      It's a whole lot easier to do the conversion here than to
3247      modify all the unexec routines to ensure that filename
3248      conversion is applied everywhere.  Don't worry about memory
3249      leakage because this call only happens once. */
3250     unexec (filename_ext, symfile_ext, (uintptr_t) my_edata, 0, 0);
3251 #ifdef DOUG_LEA_MALLOC
3252     free (malloc_state_ptr);
3253 #endif
3254 #endif /* not PDUMP */
3255   }
3256
3257   purify_flag = opurify;
3258
3259   return Qnil;
3260 }
3261
3262 #endif /* not CANNOT_DUMP */
3263 \f
3264
3265 /* Split STRING into a list of substrings.  The substrings are the
3266    parts of original STRING separated by SEPCHAR.  */
3267 static Lisp_Object
3268 split_string_by_emchar_1 (const Bufbyte *string, Bytecount size,
3269                           Emchar sepchar)
3270 {
3271   Lisp_Object result = Qnil;
3272   const Bufbyte *end = string + size;
3273
3274   while (1)
3275     {
3276       const Bufbyte *p = string;
3277       while (p < end)
3278         {
3279           if (charptr_emchar (p) == sepchar)
3280             break;
3281           INC_CHARPTR (p);
3282         }
3283       result = Fcons (make_string (string, p - string), result);
3284       if (p < end)
3285         {
3286           string = p;
3287           INC_CHARPTR (string); /* skip sepchar */
3288         }
3289       else
3290         break;
3291     }
3292   return Fnreverse (result);
3293 }
3294
3295 /* The same as the above, except PATH is an external C string (it is
3296    converted using Qfile_name), and sepchar is hardcoded to SEPCHAR
3297    (':' or whatever).  */
3298 Lisp_Object
3299 decode_path (const char *path)
3300 {
3301   Bytecount newlen;
3302   Bufbyte *newpath;
3303   if (!path)
3304     return Qnil;
3305
3306   TO_INTERNAL_FORMAT (C_STRING, path, ALLOCA, (newpath, newlen), Qfile_name);
3307
3308   /* #### Does this make sense?  It certainly does for
3309      decode_env_path(), but it looks dubious here.  Does any code
3310      depend on decode_path("") returning nil instead of an empty
3311      string?  */
3312   if (!newlen)
3313     return Qnil;
3314
3315   return split_string_by_emchar_1 (newpath, newlen, SEPCHAR);
3316 }
3317
3318 Lisp_Object
3319 decode_env_path (const char *evarname, const char *default_)
3320 {
3321   const char *path = 0;
3322   if (evarname)
3323     path = egetenv (evarname);
3324   if (!path)
3325     path = default_;
3326   return decode_path (path);
3327 }
3328
3329 /* Ben thinks this function should not exist or be exported to Lisp.
3330    We use it to define split-path-string in subr.el (not!).  */
3331
3332 DEFUN ("split-string-by-char", Fsplit_string_by_char, 2, 2, 0, /*
3333 Split STRING into a list of substrings originally separated by SEPCHAR.
3334 */
3335        (string, sepchar))
3336 {
3337   CHECK_STRING (string);
3338   CHECK_CHAR (sepchar);
3339   return split_string_by_emchar_1 (XSTRING_DATA (string),
3340                                    XSTRING_LENGTH (string),
3341                                    XCHAR (sepchar));
3342 }
3343
3344 /* #### This was supposed to be in subr.el, but is used VERY early in
3345    the bootstrap process, so it goes here.  Damn.  */
3346
3347 DEFUN ("split-path", Fsplit_path, 1, 1, 0, /*
3348 Explode a search path into a list of strings.
3349 The path components are separated with the characters specified
3350 with `path-separator'.
3351 */
3352        (path))
3353 {
3354   CHECK_STRING (path);
3355
3356   while (!STRINGP (Vpath_separator)
3357          || (XSTRING_CHAR_LENGTH (Vpath_separator) != 1))
3358     Vpath_separator = signal_simple_continuable_error
3359       ("`path-separator' should be set to a single-character string",
3360        Vpath_separator);
3361
3362   return (split_string_by_emchar_1
3363           (XSTRING_DATA (path), XSTRING_LENGTH (path),
3364            charptr_emchar (XSTRING_DATA (Vpath_separator))));
3365 }
3366 \f
3367 DEFUN ("noninteractive", Fnoninteractive, 0, 0, 0, /*
3368 Non-nil return value means XEmacs is running without interactive terminal.
3369 */
3370        ())
3371 {
3372   return noninteractive ? Qt : Qnil;
3373 }
3374
3375 /* This flag is useful to define if you're under a debugger; this way, you
3376    can put a breakpoint of assert_failed() and debug multiple problems
3377    in one session without having to recompile. */
3378 /* #define ASSERTIONS_DONT_ABORT */
3379
3380 /* This highly dubious kludge ... shut up Jamie, I'm tired of your slagging. */
3381
3382 static int in_assert_failed;
3383 static const char *assert_failed_file;
3384 static int assert_failed_line;
3385 static const char *assert_failed_expr;
3386
3387 #ifdef fprintf
3388 #undef fprintf
3389 #endif
3390
3391 #if defined (WIN32_NATIVE) && defined (DEBUG_XEMACS)
3392 #define enter_debugger() DebugBreak ()
3393 #else
3394 #define enter_debugger()
3395 #endif
3396
3397 void
3398 assert_failed (const char *file, int line, const char *expr)
3399 {
3400   /* If we're already crashing, let's not crash again.  This might be
3401      critical to getting auto-saving working properly. */
3402   if (fatal_error_in_progress)
3403     return;
3404
3405   /* We are extremely paranoid so we sensibly deal with recursive
3406      assertion failures. */
3407   in_assert_failed++;
3408   inhibit_non_essential_printing_operations = 1;
3409
3410   if (in_assert_failed >= 4)
3411     _exit (-1);
3412   else if (in_assert_failed == 3)
3413     {
3414       enter_debugger ();
3415       _exit (-1);
3416     }
3417   else if (in_assert_failed == 2)
3418     {
3419       /* Not stderr_out(), which does additional things and may trigger
3420          a recursive assertion failure.  fprintf was undeffed above, in
3421          case it was encapsulated. */
3422       fprintf (stderr,
3423                "Fatal error: recursive assertion failure, "
3424                "file %s, line %d, %s\n",
3425                file, line, expr);
3426       fprintf (stderr,
3427                "Original assertion failure: file %s, line %d, %s\n",
3428                assert_failed_file, assert_failed_line, assert_failed_expr);
3429     }
3430   else
3431     {
3432       assert_failed_file = file;
3433       assert_failed_line = line;
3434       assert_failed_expr = expr;
3435
3436       if (!initialized)
3437         fprintf (stderr,
3438                  "Fatal error: assertion failed, file %s, line %d, %s\n",
3439                  file, line, expr);
3440       else
3441         stderr_out ("Fatal error: assertion failed, file %s, line %d, %s\n",
3442                     file, line, expr);
3443     }
3444
3445   enter_debugger ();
3446 #if !defined (ASSERTIONS_DONT_ABORT)
3447   abort (); /* The real abort(), this time */
3448 #endif
3449   inhibit_non_essential_printing_operations = 0;
3450   in_assert_failed = 0;
3451 }
3452
3453 #ifdef QUANTIFY
3454 DEFUN ("quantify-start-recording-data", Fquantify_start_recording_data,
3455        0, 0, "", /*
3456 Start recording Quantify data.
3457 */
3458        ())
3459 {
3460   quantify_start_recording_data ();
3461   return Qnil;
3462 }
3463
3464 DEFUN ("quantify-stop-recording-data", Fquantify_stop_recording_data,
3465        0, 0, "", /*
3466 Stop recording Quantify data.
3467 */
3468        ())
3469 {
3470   quantify_stop_recording_data ();
3471   return Qnil;
3472 }
3473
3474 DEFUN ("quantify-clear-data", Fquantify_clear_data, 0, 0, "", /*
3475 Clear all Quantify data.
3476 */
3477        ())
3478 {
3479   quantify_clear_data ();
3480   return Qnil;
3481 }
3482 #endif /* QUANTIFY */
3483
3484 void
3485 syms_of_emacs (void)
3486 {
3487 #ifndef CANNOT_DUMP
3488   DEFSUBR (Fdump_emacs);
3489 #endif /* !CANNOT_DUMP */
3490
3491   DEFSUBR (Frun_emacs_from_temacs);
3492   DEFSUBR (Frunning_temacs_p);
3493   DEFSUBR (Finvocation_name);
3494   DEFSUBR (Finvocation_directory);
3495   DEFSUBR (Fkill_emacs);
3496   DEFSUBR (Fnoninteractive);
3497
3498 #ifdef DEBUG_XEMACS
3499   DEFSUBR (Fforce_debugging_signal);
3500 #endif
3501
3502 #ifdef QUANTIFY
3503   DEFSUBR (Fquantify_start_recording_data);
3504   DEFSUBR (Fquantify_stop_recording_data);
3505   DEFSUBR (Fquantify_clear_data);
3506 #endif /* QUANTIFY */
3507
3508   DEFSUBR (Fsplit_string_by_char);
3509   DEFSUBR (Fsplit_path);        /* #### */
3510
3511   defsymbol (&Qkill_emacs_hook, "kill-emacs-hook");
3512   defsymbol (&Qsave_buffers_kill_emacs, "save-buffers-kill-emacs");
3513 }
3514
3515 void
3516 vars_of_emacs (void)
3517 {
3518   DEFVAR_BOOL ("suppress-early-error-handler-backtrace",
3519                &suppress_early_error_handler_backtrace /*
3520 Non-nil means early error handler shouldn't print a backtrace.
3521 */ );
3522
3523   DEFVAR_LISP ("command-line-args", &Vcommand_line_args /*
3524 Args passed by shell to XEmacs, as a list of strings.
3525 */ );
3526
3527   DEFVAR_LISP ("invocation-name", &Vinvocation_name /*
3528 The program name that was used to run XEmacs.
3529 Any directory names are omitted.
3530 */ );
3531
3532   DEFVAR_LISP ("invocation-directory", &Vinvocation_directory /*
3533 The directory in which the XEmacs executable was found, to run it.
3534 The value is simply the program name if that directory's name is not known.
3535 */ );
3536
3537   DEFVAR_LISP ("invocation-path", &Vinvocation_path /*
3538 The path in which the XEmacs executable was found, to run it.
3539 The value is simply the value of environment variable PATH on startup
3540 if XEmacs was found there.
3541 */ );
3542
3543 #if 0 /* FSFmacs */
3544   xxDEFVAR_LISP ("installation-directory", &Vinstallation_directory,
3545     "A directory within which to look for the `lib-src' and `etc' directories.\n"
3546 "This is non-nil when we can't find those directories in their standard\n"
3547 "installed locations, but we can find them\n"
3548 "near where the XEmacs executable was found.");
3549 #endif
3550
3551   DEFVAR_LISP ("system-type", &Vsystem_type /*
3552 Symbol indicating type of operating system you are using.
3553 */ );
3554   Vsystem_type = intern (SYSTEM_TYPE);
3555   Fprovide (intern(SYSTEM_TYPE));
3556
3557 #ifndef EMACS_CONFIGURATION
3558 # define EMACS_CONFIGURATION "UNKNOWN"
3559 #endif
3560   DEFVAR_LISP ("system-configuration", &Vsystem_configuration /*
3561 String naming the configuration XEmacs was built for.
3562 */ );
3563   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
3564
3565 #ifndef EMACS_CONFIG_OPTIONS
3566 # define EMACS_CONFIG_OPTIONS "UNKNOWN"
3567 #endif
3568   DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options /*
3569 String containing the configuration options XEmacs was built with.
3570 */ );
3571   Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS);
3572
3573   DEFVAR_LISP ("emacs-major-version", &Vemacs_major_version /*
3574 Major version number of this version of Emacs, as an integer.
3575 Warning: this variable did not exist in Emacs versions earlier than:
3576   FSF Emacs:   19.23
3577   XEmacs:      19.10
3578 */ );
3579   Vemacs_major_version = make_int (EMACS_MAJOR_VERSION);
3580
3581   DEFVAR_LISP ("emacs-minor-version", &Vemacs_minor_version /*
3582 Minor version number of this version of Emacs, as an integer.
3583 Warning: this variable did not exist in Emacs versions earlier than:
3584   FSF Emacs:   19.23
3585   XEmacs:      19.10
3586 */ );
3587   Vemacs_minor_version = make_int (EMACS_MINOR_VERSION);
3588
3589   DEFVAR_LISP ("emacs-patch-level", &Vemacs_patch_level /*
3590 The patch level of this version of Emacs, as an integer.
3591 The value is non-nil if this version of XEmacs is part of a series of
3592 stable XEmacsen, but has bug fixes applied.
3593 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3594 earlier than 21.1.1
3595 */ );
3596 #ifdef EMACS_PATCH_LEVEL
3597   Vemacs_patch_level = make_int (EMACS_PATCH_LEVEL);
3598 #else
3599   Vemacs_patch_level = Qnil;
3600 #endif
3601
3602     DEFVAR_LISP ("emacs-beta-version", &Vemacs_beta_version /*
3603 Beta number of this version of Emacs, as an integer.
3604 The value is nil if this is an officially released version of XEmacs.
3605 Warning: this variable does not exist in FSF Emacs or in XEmacs versions
3606 earlier than 20.3.
3607 */ );
3608 #ifdef EMACS_BETA_VERSION
3609   Vemacs_beta_version = make_int (EMACS_BETA_VERSION);
3610 #else
3611   Vemacs_beta_version = Qnil;
3612 #endif
3613
3614 #ifdef INFODOCK
3615   DEFVAR_LISP ("infodock-major-version", &Vinfodock_major_version /*
3616 Major version number of this InfoDock release.
3617 */ );
3618   Vinfodock_major_version = make_int (INFODOCK_MAJOR_VERSION);
3619
3620   DEFVAR_LISP ("infodock-minor-version", &Vinfodock_minor_version /*
3621 Minor version number of this InfoDock release.
3622 */ );
3623   Vinfodock_minor_version = make_int (INFODOCK_MINOR_VERSION);
3624
3625   DEFVAR_LISP ("infodock-build-version", &Vinfodock_build_version /*
3626 Build version of this InfoDock release.
3627 */ );
3628   Vinfodock_build_version = make_int (INFODOCK_BUILD_VERSION);
3629 #endif
3630
3631   DEFVAR_LISP ("xemacs-codename", &Vxemacs_codename /*
3632 Codename of this version of Emacs (a string).
3633 */ );
3634 #ifndef XEMACS_CODENAME
3635 #define XEMACS_CODENAME "Noname"
3636 #endif
3637 #ifdef MULE
3638   {
3639     char dest[129];
3640     char src[64] = XEMACS_CODENAME;
3641     unsigned char* sp = (unsigned char*)src;
3642     int i = 0, chr;
3643
3644     while ( (chr = *sp++) && (i < 128) )
3645       {
3646         if (chr <= 0x7F)
3647           dest[i++] = chr;
3648         else
3649           {
3650 #ifdef UTF2000
3651             dest[i++] = (chr >> 6) | 0xC0;
3652             dest[i++] = (chr & 0x3F) | 0x80;
3653 #else
3654             dest[i++] = LEADING_BYTE_LATIN_ISO8859_1;
3655             dest[i++] = chr;
3656 #endif
3657           }
3658       }
3659     dest[i] = 0;
3660     Vxemacs_codename = build_string (dest);
3661   }
3662 #else  
3663   Vxemacs_codename = build_string (XEMACS_CODENAME);
3664 #endif
3665
3666   /* Lisp variables which contain command line flags.
3667
3668      The portable dumper stomps on these; they must be saved and restored
3669      if they are processed before the call to pdump_load() in main_1().
3670   */
3671   DEFVAR_BOOL ("noninteractive", &noninteractive1 /*
3672 Non-nil means XEmacs is running without interactive terminal.
3673 */ );
3674
3675   DEFVAR_BOOL ("inhibit-early-packages", &inhibit_early_packages /*
3676 Set to non-nil when the early packages should not be respected at startup.
3677 */ );
3678
3679   DEFVAR_BOOL ("inhibit-autoloads", &inhibit_autoloads /*
3680 Set to non-nil when autoloads should not be loaded at startup.
3681 */ );
3682
3683   DEFVAR_BOOL ("debug-paths", &debug_paths /*
3684 Set to non-nil when debug information about paths should be printed.
3685 */ );
3686
3687   DEFVAR_BOOL ("inhibit-site-lisp", &inhibit_site_lisp /*
3688 Set to non-nil when the site-lisp should not be searched at startup.
3689 */ );
3690 #ifdef INHIBIT_SITE_LISP
3691   inhibit_site_lisp = 1;
3692 #endif
3693
3694   DEFVAR_BOOL ("inhibit-site-modules", &inhibit_site_modules /*
3695 Set to non-nil when site-modules should not be searched at startup.
3696 */ );
3697 #ifdef INHIBIT_SITE_MODULES
3698   inhibit_site_modules = 1;
3699 #endif
3700
3701   DEFVAR_INT ("emacs-priority", &emacs_priority /*
3702 Priority for XEmacs to run at.
3703 This value is effective only if set before XEmacs is dumped,
3704 and only if the XEmacs executable is installed with setuid to permit
3705 it to change priority.  (XEmacs sets its uid back to the real uid.)
3706 Currently, you need to define SET_EMACS_PRIORITY in `config.h'
3707 before you compile XEmacs, to enable the code for this feature.
3708 */ );
3709   emacs_priority = 0;
3710
3711   DEFVAR_CONST_LISP ("internal-error-checking", &Vinternal_error_checking /*
3712 Internal error checking built-in into this instance of XEmacs.
3713 This is a list of symbols, initialized at build-time.  Legal symbols
3714 are:
3715
3716 extents         - check extents prior to each extent change;
3717 typecheck       - check types strictly, aborting in case of error;
3718 malloc          - check operation of malloc;
3719 gc              - check garbage collection;
3720 bufpos          - check buffer positions.
3721
3722 quick-build     - user has requested the "quick-build" configure option.
3723 */ );
3724   Vinternal_error_checking = Qnil;
3725 #ifdef ERROR_CHECK_EXTENTS
3726   Vinternal_error_checking = Fcons (intern ("extents"),
3727                                     Vinternal_error_checking);
3728 #endif
3729 #ifdef ERROR_CHECK_TYPECHECK
3730   Vinternal_error_checking = Fcons (intern ("typecheck"),
3731                                     Vinternal_error_checking);
3732 #endif
3733 #ifdef ERROR_CHECK_MALLOC
3734   Vinternal_error_checking = Fcons (intern ("malloc"),
3735                                     Vinternal_error_checking);
3736 #endif
3737 #ifdef ERROR_CHECK_GC
3738   Vinternal_error_checking = Fcons (intern ("gc"),
3739                                     Vinternal_error_checking);
3740 #endif
3741 #ifdef ERROR_CHECK_BUFPOS
3742   Vinternal_error_checking = Fcons (intern ("bufpos"),
3743                                     Vinternal_error_checking);
3744 #endif
3745 #ifdef QUICK_BUILD
3746   Vinternal_error_checking = Fcons (intern ("quick-build"),
3747                                     Vinternal_error_checking);
3748 #endif
3749
3750   DEFVAR_CONST_LISP ("mail-lock-methods", &Vmail_lock_methods /*
3751 Mail spool locking methods supported by this instance of XEmacs.
3752 This is a list of symbols.  Each of the symbols is one of the
3753 following: dot, lockf, flock, locking, mmdf.
3754 */ );
3755   {
3756     Vmail_lock_methods = Qnil;
3757     Vmail_lock_methods = Fcons (intern ("dot"), Vmail_lock_methods);
3758 #ifdef HAVE_LOCKF
3759     Vmail_lock_methods = Fcons (intern ("lockf"), Vmail_lock_methods);
3760 #endif
3761 #ifdef HAVE_FLOCK
3762     Vmail_lock_methods = Fcons (intern ("flock"), Vmail_lock_methods);
3763 #endif
3764 #ifdef HAVE_MMDF
3765     Vmail_lock_methods = Fcons (intern ("mmdf"), Vmail_lock_methods);
3766 #endif
3767 #ifdef HAVE_LOCKING
3768     Vmail_lock_methods = Fcons (intern ("locking"), Vmail_lock_methods);
3769 #endif
3770   }
3771
3772   DEFVAR_CONST_LISP ("configure-mail-lock-method", &Vconfigure_mail_lock_method /*
3773 Mail spool locking method suggested by configure.  This is one
3774 of the symbols in MAIL-LOCK-METHODS.
3775 */ );
3776   {
3777 #if defined(MAIL_LOCK_FLOCK) && defined(HAVE_FLOCK)
3778     Vconfigure_mail_lock_method = intern("flock");
3779 #elif defined(MAIL_LOCK_LOCKF) && defined(HAVE_LOCKF)
3780     Vconfigure_mail_lock_method = intern("lockf");
3781 #elif defined(MAIL_LOCK_MMDF) && defined(HAVE_MMDF)
3782     Vconfigure_mail_lock_method = intern("mmdf");
3783 #elif defined(MAIL_LOCK_LOCKING) && defined(HAVE_LOCKING)
3784     Vconfigure_mail_lock_method = intern("locking");
3785 #else
3786     Vconfigure_mail_lock_method = intern("dot");
3787 #endif
3788   }
3789
3790   DEFVAR_LISP ("path-separator", &Vpath_separator /*
3791 The directory separator in search paths, as a string.
3792 */ );
3793   {
3794     char c = SEPCHAR;
3795     Vpath_separator = make_string ((Bufbyte *)&c, 1);
3796   }
3797 }
3798
3799 void
3800 complex_vars_of_emacs (void)
3801 {
3802   /* This is all related to path searching. */
3803
3804   DEFVAR_LISP ("emacs-program-name", &Vemacs_program_name /*
3805 *Name of the Emacs variant.
3806 For example, this may be \"xemacs\" or \"infodock\".
3807 This is mainly meant for use in path searching.
3808 */ );
3809   Vemacs_program_name = build_string ((char *) PATH_PROGNAME);
3810
3811   DEFVAR_LISP ("emacs-program-version", &Vemacs_program_version /*
3812 *Version of the Emacs variant.
3813 This typically has the form NN.NN-bNN.
3814 This is mainly meant for use in path searching.
3815 */ );
3816   Vemacs_program_version = build_string ((char *) PATH_VERSION);
3817
3818   DEFVAR_LISP ("exec-path", &Vexec_path /*
3819 *List of directories to search programs to run in subprocesses.
3820 Each element is a string (directory name) or nil (try default directory).
3821 */ );
3822   Vexec_path = Qnil;
3823
3824   DEFVAR_LISP ("exec-directory", &Vexec_directory /*
3825 *Directory of architecture-dependent files that come with XEmacs,
3826 especially executable programs intended for XEmacs to invoke.
3827 */ );
3828   Vexec_directory = Qnil;
3829
3830   DEFVAR_LISP ("configure-exec-directory", &Vconfigure_exec_directory /*
3831 For internal use by the build procedure only.
3832 configure's idea of what `exec-directory' will be.
3833 */ );
3834 #ifdef PATH_EXEC
3835   Vconfigure_exec_directory = Ffile_name_as_directory
3836     (build_string ((char *) PATH_EXEC));
3837 #else
3838   Vconfigure_exec_directory = Qnil;
3839 #endif
3840
3841   DEFVAR_LISP ("lisp-directory", &Vlisp_directory /*
3842 *Directory of core Lisp files that come with XEmacs.
3843 */ );
3844   Vlisp_directory = Qnil;
3845
3846   DEFVAR_LISP ("configure-lisp-directory", &Vconfigure_lisp_directory /*
3847 For internal use by the build procedure only.
3848 configure's idea of what `lisp-directory' will be.
3849 */ );
3850 #ifdef PATH_LOADSEARCH
3851   Vconfigure_lisp_directory = Ffile_name_as_directory
3852     (build_string ((char *) PATH_LOADSEARCH));
3853 #else
3854   Vconfigure_lisp_directory = Qnil;
3855 #endif
3856
3857   DEFVAR_LISP ("mule-lisp-directory", &Vmule_lisp_directory /*
3858 *Directory of Mule Lisp files that come with XEmacs.
3859 */ );
3860   Vmule_lisp_directory = Qnil;
3861
3862   DEFVAR_LISP ("configure-mule-lisp-directory", &Vconfigure_mule_lisp_directory /*
3863 For internal use by the build procedure only.
3864 configure's idea of what `mule-lisp-directory' will be.
3865 */ );
3866 #ifdef PATH_MULELOADSEARCH
3867   Vconfigure_mule_lisp_directory = Ffile_name_as_directory
3868     (build_string ((char *) PATH_MULELOADSEARCH));
3869 #else
3870   Vconfigure_mule_lisp_directory = Qnil;
3871 #endif
3872
3873   DEFVAR_LISP ("utf-2000-lisp-directory", &Vutf_2000_lisp_directory /*
3874 *Directory of UTF-2000 Lisp files that come with XEmacs.
3875 */ );
3876   Vutf_2000_lisp_directory = Qnil;
3877
3878   DEFVAR_LISP ("configure-utf-2000-lisp-directory",
3879                &Vconfigure_utf_2000_lisp_directory /*
3880 For internal use by the build procedure only.
3881 configure's idea of what `utf-2000-lisp-directory' will be.
3882 */ );
3883 #ifdef PATH_UTF2000LOADSEARCH
3884   Vconfigure_utf_2000_lisp_directory = Ffile_name_as_directory
3885     (build_string ((char *) PATH_UTF2000LOADSEARCH));
3886 #else
3887   Vconfigure_utf_2000_lisp_directory = Qnil;
3888 #endif
3889
3890   DEFVAR_LISP ("module-directory", &Vmodule_directory /*
3891 *Directory of core dynamic modules that come with XEmacs.
3892 */ );
3893   Vmodule_directory = Qnil;
3894
3895   DEFVAR_LISP ("configure-module-directory", &Vconfigure_module_directory /*
3896 For internal use by the build procedure only.
3897 configure's idea of what `module-directory' will be.
3898 */ );
3899 #ifdef PATH_MODULESEARCH
3900   Vconfigure_module_directory = Ffile_name_as_directory
3901     (build_string ((char *) PATH_MODULESEARCH));
3902 #else
3903   Vconfigure_module_directory = Qnil;
3904 #endif
3905
3906   DEFVAR_LISP ("configure-package-path", &Vconfigure_package_path /*
3907 For internal use by the build procedure only.
3908 configure's idea of what the package path will be.
3909 */ );
3910 #ifdef PATH_PACKAGEPATH
3911   Vconfigure_package_path = decode_path (PATH_PACKAGEPATH);
3912 #else
3913   Vconfigure_package_path = Qnil;
3914 #endif
3915
3916   DEFVAR_LISP ("data-directory", &Vdata_directory /*
3917 *Directory of architecture-independent files that come with XEmacs,
3918 intended for XEmacs to use.
3919 Use of this variable in new code is almost never correct.  See the
3920 functions `locate-data-file' and `locate-data-directory' and the variable
3921 `data-directory-list'.
3922 */ );
3923   Vdata_directory = Qnil;
3924
3925   DEFVAR_LISP ("configure-data-directory", &Vconfigure_data_directory /*
3926 For internal use by the build procedure only.
3927 configure's idea of what `data-directory' will be.
3928 */ );
3929 #ifdef PATH_DATA
3930   Vconfigure_data_directory = Ffile_name_as_directory
3931     (build_string ((char *) PATH_DATA));
3932 #else
3933   Vconfigure_data_directory = Qnil;
3934 #endif
3935
3936   DEFVAR_LISP ("data-directory-list", &Vdata_directory_list /*
3937 *List of directories of architecture-independent files that come with XEmacs
3938 or were installed as packages, and are intended for XEmacs to use.
3939 */ );
3940   Vdata_directory_list = Qnil;
3941
3942   DEFVAR_LISP ("site-directory", &Vsite_directory /*
3943 *Directory of site-specific Lisp files that come with XEmacs.
3944 */ );
3945   Vsite_directory = Qnil;
3946
3947   DEFVAR_LISP ("configure-site-directory", &Vconfigure_site_directory /*
3948 For internal use by the build procedure only.
3949 configure's idea of what `site-directory' will be.
3950 */ );
3951 #ifdef PATH_SITE
3952   Vconfigure_site_directory = Ffile_name_as_directory
3953     (build_string ((char *) PATH_SITE));
3954 #else
3955   Vconfigure_site_directory = Qnil;
3956 #endif
3957
3958   DEFVAR_LISP ("site-module-directory", &Vsite_module_directory /*
3959 *Directory of site-specific loadable modules that come with XEmacs.
3960 */ );
3961   Vsite_module_directory = Qnil;
3962
3963   DEFVAR_LISP ("configure-site-module-directory", &Vconfigure_site_module_directory /*
3964 For internal use by the build procedure only.
3965 configure's idea of what `site-directory' will be.
3966 */ );
3967 #ifdef PATH_SITE_MODULES
3968   Vconfigure_site_module_directory = Ffile_name_as_directory
3969     (build_string ((char *) PATH_SITE_MODULES));
3970 #else
3971   Vconfigure_site_module_directory = Qnil;
3972 #endif
3973
3974   DEFVAR_LISP ("doc-directory", &Vdoc_directory /*
3975 *Directory containing the DOC file that comes with XEmacs.
3976 This is usually the same as `exec-directory'.
3977 */ );
3978   Vdoc_directory = Qnil;
3979
3980   DEFVAR_LISP ("configure-doc-directory", &Vconfigure_doc_directory /*
3981 For internal use by the build procedure only.
3982 configure's idea of what `doc-directory' will be.
3983 */ );
3984 #ifdef PATH_DOC
3985   Vconfigure_doc_directory = Ffile_name_as_directory
3986     (build_string ((char *) PATH_DOC));
3987 #else
3988   Vconfigure_doc_directory = Qnil;
3989 #endif
3990
3991   DEFVAR_LISP ("configure-exec-prefix-directory", &Vconfigure_exec_prefix_directory /*
3992 For internal use by the build procedure only.
3993 configure's idea of what `exec-prefix-directory' will be.
3994 */ );
3995 #ifdef PATH_EXEC_PREFIX
3996   Vconfigure_exec_prefix_directory = Ffile_name_as_directory
3997     (build_string ((char *) PATH_EXEC_PREFIX));
3998 #else
3999   Vconfigure_exec_prefix_directory = Qnil;
4000 #endif
4001
4002   DEFVAR_LISP ("configure-prefix-directory", &Vconfigure_prefix_directory /*
4003 For internal use by the build procedure only.
4004 configure's idea of what `prefix-directory' will be.
4005 */ );
4006 #ifdef PATH_PREFIX
4007   Vconfigure_prefix_directory = Ffile_name_as_directory
4008     (build_string ((char *) PATH_PREFIX));
4009 #else
4010   Vconfigure_prefix_directory = Qnil;
4011 #endif
4012
4013   DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory /*
4014 For internal use by the build procedure only.
4015 This is the name of the directory in which the build procedure installed
4016 Emacs's info files; the default value for Info-default-directory-list
4017 includes this.
4018 */ );
4019 #ifdef PATH_INFO
4020   Vconfigure_info_directory =
4021     Ffile_name_as_directory (build_string (PATH_INFO));
4022 #else
4023   Vconfigure_info_directory = Qnil;
4024 #endif
4025
4026   DEFVAR_LISP ("configure-info-path", &Vconfigure_info_path /*
4027 The configured initial path for info documentation.
4028 */ );
4029 #ifdef PATH_INFOPATH
4030   Vconfigure_info_path = decode_path (PATH_INFOPATH);
4031 #else
4032   Vconfigure_info_path = Qnil;
4033 #endif
4034 }
4035
4036 #if defined(__sgi) && !defined(PDUMP)
4037 /* This is so tremendously ugly I'd puke. But then, it works.
4038  * The target is to override the static constructor from the
4039  * libiflPNG.so library which is masquerading as libz, and
4040  * cores on us when re-started from the dumped executable.
4041  * This will have to go for 21.1  -- OG.
4042  */
4043 void __sti__iflPNGFile_c___ (void);
4044 void
4045 __sti__iflPNGFile_c___ (void)
4046 {
4047 }
4048
4049 #endif