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