update.
[chise/xemacs-chise.git] / lisp / startup.el
1 ;;; startup.el --- process XEmacs shell arguments
2
3 ;; Copyright (C) 1985-1986, 1990, 1992-1997 Free Software Foundation, Inc.
4 ;; Copyright (c) 1993, 1994 Sun Microsystems, Inc.
5 ;; Copyright (C) 1995 Board of Trustees, University of Illinois
6
7 ;; Maintainer: XEmacs Development Team
8 ;; Keywords: internal, dumped
9
10 ;; This file is part of XEmacs.
11
12 ;; XEmacs is free software; you can redistribute it and/or modify it
13 ;; under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; any later version.
16
17 ;; XEmacs is distributed in the hope that it will be useful, but
18 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20 ;; General Public License for more details.
21
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with XEmacs; see the file COPYING.  If not, write to the
24 ;; Free Software Foundation, 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
26
27 ;;; Synched up with: FSF 19.34.
28
29 ;;; Commentary:
30
31 ;; This file is dumped with XEmacs.
32
33 ;; -batch, -t, and -nw are processed by main() in emacs.c and are
34 ;; never seen by lisp code.
35
36 ;; -version and -help are special-cased as well: they imply -batch,
37 ;; but are left on the list for lisp code to process.
38
39 ;;; Code:
40 \f
41 (setq top-level '(normal-top-level))
42
43 (defvar command-line-processed nil "t once command line has been processed")
44
45 (defconst startup-message-timeout 12000) ; More or less disable the timeout
46 (defconst splash-frame-timeout 7) ; interval between splash frame elements
47
48 (defconst inhibit-startup-message nil
49   "*Non-nil inhibits the initial startup message.
50 This is for use in your personal init file, once you are familiar
51 with the contents of the startup message.")
52
53 ;; #### FSFmacs randomness
54 ;;(defconst inhibit-startup-echo-area-message nil
55 ;;  "*Non-nil inhibits the initial startup echo area message.
56 ;;Inhibition takes effect only if your `.emacs' file contains
57 ;;a line of this form:
58 ;; (setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\")
59 ;;If your `.emacs' file is byte-compiled, use the following form instead:
60 ;; (eval '(setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\"))
61 ;;Thus, someone else using a copy of your `.emacs' file will see
62 ;;the startup message unless he personally acts to inhibit it.")
63
64 (defconst inhibit-default-init nil
65   "*Non-nil inhibits loading the `default' library.")
66
67 (defvar command-line-args-left nil
68   "List of command-line args not yet processed.") ; bound by `command-line'
69
70 (defvar command-line-default-directory nil
71   "Default directory to use for command line arguments.
72 This is normally copied from `default-directory' when XEmacs starts.")
73
74 (defvar before-init-hook nil
75   "Functions to call after handling urgent options but before init files.
76 The frame system uses this to open frames to display messages while
77 XEmacs loads the user's initialization file.")
78
79 (defvar after-init-hook nil
80   "*Functions to call after loading the init file.
81 The call is not protected by a condition-case, so you can set `debug-on-error'
82 in the init file, and put all the actual code on `after-init-hook'.")
83
84 (defvar term-setup-hook nil
85   "*Functions to be called after loading terminal-specific Lisp code.
86 See `run-hooks'.  This variable exists for users to set, so as to
87 override the definitions made by the terminal-specific file.  XEmacs
88 never sets this variable itself.")
89
90 (defvar keyboard-type nil
91   "The brand of keyboard you are using.
92 This variable is used to define the proper function and keypad keys
93 for use under X.  It is used in a fashion analogous to the environment
94 value TERM.")
95
96 (defvar window-setup-hook nil
97   "Normal hook run to initialize window system display.
98 XEmacs runs this hook after processing the command line arguments and loading
99 the user's init file.")
100
101 (defconst initial-major-mode 'lisp-interaction-mode
102   "Major mode command symbol to use for the initial *scratch* buffer.")
103
104 (defvar emacs-roots nil
105   "List of plausible roots of the XEmacs hierarchy.")
106
107 (defvar user-init-directory-base ".xemacs"
108   "Base of directory where user-installed init files may go.")
109
110 (defvar user-init-directory
111   (file-name-as-directory
112    (paths-construct-path (list "~" user-init-directory-base)))
113   "Directory where user-installed init files may go.")
114
115 (defvar user-init-file-base "init.el"
116   "Default name of the user init file if uncompiled.
117 This should be used for migration purposes only.")
118
119 (defvar user-init-file-base-list '("init.elc" "init.el")
120   "List of allowed init files in the user's init directory.
121 The first one found takes precedence.")
122
123 (defvar user-home-init-file-base-list
124   (append '(".emacs.elc" ".emacs.el" ".emacs")
125           (and (eq system-type 'windows-nt)
126                '("_emacs.elc" "_emacs.el" "_emacs")))
127   "List of allowed init files in the user's home directory.
128 The first one found takes precedence.")
129
130 (defvar load-home-init-file nil
131   "Non-nil if XEmacs should load the init file from the home directory.
132 Otherwise, XEmacs will offer migration to the init directory.")
133
134 (defvar load-user-init-file-p t
135   "Non-nil if XEmacs should load the user's init file.")
136
137 ;; #### called `site-run-file' in FSFmacs
138
139 (defvar site-start-file "site-start"
140   "File containing site-wide run-time initializations.
141 This file is loaded at run-time before `.emacs'.  It
142 contains inits that need to be in place for the entire site, but
143 which, due to their higher incidence of change, don't make sense to
144 load into XEmacs' dumped image.  Thus, the run-time load order is:
145
146   1. file described in this variable, if non-nil;
147   2. `.emacs';
148   3. `/path/to/xemacs/lisp/default.el'.
149
150 Don't use the `site-start.el' file for things some users may not like.
151 Put them in `default.el' instead, so that users can more easily
152 override them.  Users can prevent loading `default.el' with the `-q'
153 option or by setting `inhibit-default-init' in their own init files,
154 but inhibiting `site-start.el' requires `--no-site-file', which
155 is less convenient.")
156
157 ;;(defconst iso-8859-1-locale-regexp "8859[-_]?1"
158 ;;  "Regexp that specifies when to enable the ISO 8859-1 character set.
159 ;;We do that if this regexp matches the locale name
160 ;;specified by the LC_ALL, LC_CTYPE and LANG environment variables.")
161
162 (defcustom mail-host-address nil
163   "*Name of this machine, for purposes of naming users."
164   :type 'string
165   :group 'mail)
166
167 (defcustom user-mail-address nil
168   "*Full mailing address of this user.
169 This is initialized based on `mail-host-address',
170 after your init file is read, in case it sets `mail-host-address'."
171   :type 'string
172   :group 'mail)
173
174 (defvar init-file-debug nil)
175
176 (defvar init-file-had-error nil)
177
178 (defvar init-file-loaded nil
179   "True after the user's init file has been loaded (or suppressed with -q).
180 This will be true when `after-init-hook' is run and at all times
181 after, and will not be true at any time before.")
182
183 (defvar initial-frame-unmapped-p nil)
184
185 \f
186
187 (defvar command-switch-alist
188   '(("-help"    . command-line-do-help)
189     ("-version". command-line-do-version)
190     ("-V"       . command-line-do-version)
191     ("-funcall". command-line-do-funcall)
192     ("-f"       . command-line-do-funcall)
193     ("-e"       . command-line-do-funcall-1)
194     ("-eval"    . command-line-do-eval)
195     ("-load"    . command-line-do-load)
196     ("-l"       . command-line-do-load)
197     ("-insert"  . command-line-do-insert)
198     ("-i"       . command-line-do-insert)
199     ("-kill"    . command-line-do-kill)
200     ;; Options like +35 are handled specially.
201     ;; Window-system, site, or package-specific code might add to this.
202     ;; X11 handles its options by letting Xt remove args from this list.
203     )
204   "Alist of command-line switches.
205 Elements look like (SWITCH-STRING . HANDLER-FUNCTION).
206 HANDLER-FUNCTION receives switch name as sole arg;
207 remaining command-line args are in the variable `command-line-args-left'.")
208
209 ;;; default switches
210 ;;; Note: these doc strings are semi-magical.
211
212 (defun command-line-do-help (arg)
213   "Print the XEmacs usage message and exit."
214   (let ((standard-output 'external-debugging-output))
215     (princ (concat "\n" (emacs-version) "\n\n"))
216     (princ
217      (if (featurep 'x)
218          (concat "When creating a window on an X display, "
219                  (emacs-name)
220                  " accepts all standard X Toolkit
221 command line options plus the following:
222   -iconname <title>     Use title as the icon name.
223   -mc <color>           Use color as the mouse color.
224   -cr <color>           Use color as the text-cursor foregound color.
225   -private              Install a private colormap.
226
227 In addition, the")
228        "The"))
229     (princ " following options are accepted:
230   -sd                   Show dump ID.  Ignored when configured without --pdump.
231   -nd                   Don't load the dump file.  Roughly like old temacs.
232                         Ignored when configured without --pdump.
233   -t <device>           Use TTY <device> instead of the terminal for input
234                         and output.  This implies the -nw option.
235   -nw                   Inhibit the use of any window-system-specific
236                         display code: use the current tty.
237   -batch                Execute noninteractively (messages go to stderr).
238   -debug-init           Enter the debugger if an error in the init file occurs.
239   -unmapped             Do not map the initial frame.
240   -no-site-file         Do not load the site-specific init file (site-start.el).
241   -no-init-file         Do not load the user-specific init file.
242   -no-early-packages    Do not process early packages.
243   -no-autoloads         Do not load global symbol files (auto-autoloads) at
244                         startup.  Also implies `-vanilla'.
245   -vanilla              Equivalent to -q -no-site-file -no-early-packages.
246   -q                    Same as -no-init-file.
247   -user-init-file <file> Use <file> as init file.
248   -user-init-directory <directory> Use <directory> as init directory.
249   -user <user>          Load user's init file instead of your own.
250   -u <user>             Same as -user.\n")
251    (let ((l command-switch-alist)
252           (insert (lambda (&rest x)
253                     (princ "  ")
254                     (let ((len 2))
255                       (while x
256                         (princ (car x))
257                         (incf len (length (car x)))
258                         (setq x (cdr x)))
259                       (when (>= len 24)
260                         (terpri) (setq len 0))
261                       (while (< len 24)
262                         (princ " ")
263                         (incf len))))))
264       (while l
265         (let ((name (car (car l)))
266               (fn (cdr (car l)))
267               doc arg cons)
268           (cond
269            ((and (symbolp fn) (get fn 'undocumented)) nil)
270            (t
271             (setq doc (documentation fn))
272             (if (member doc '(nil "")) (setq doc "(undocumented)"))
273             (cond ((string-match "\n\\(<.*>\\)\n?\\'" doc)
274                    ;; Doc of the form "The frobber switch\n<arg1> <arg2>"
275                    (setq arg (substring doc (match-beginning 1) (match-end 1))
276                          doc (substring doc 0 (match-beginning 0))))
277                   ((string-match "\n+\\'" doc)
278                    (setq doc (substring doc 0 (match-beginning 0)))))
279             (if (and (setq cons (rassq fn command-switch-alist))
280                      (not (eq cons (car l))))
281                 (setq doc (format "Same as %s." (car cons))))
282             (if arg
283                 (funcall insert name " " arg)
284               (funcall insert name))
285             (princ doc)
286             (terpri))))
287         (setq l (cdr l))))
288     (princ (concat "\
289   +N <file>             Start displaying <file> at line N.
290
291 Anything else is considered a file name, and is placed into a buffer for
292 editing.
293
294 " (emacs-name) " has an online tutorial and manuals.  Type ^Ht (Control-h t) after
295 starting XEmacs to run the tutorial.  Type ^Hi to enter the manual browser.
296 Type ^H^H^H (Control-h Control-h Control-h) to get more help options.\n")
297
298     (kill-emacs 0))))
299
300 (defun command-line-do-funcall (arg)
301   "Invoke the named lisp function with no arguments.
302 <function>"
303   (funcall (intern (pop command-line-args-left))))
304 (fset 'command-line-do-funcall-1 'command-line-do-funcall)
305 (put 'command-line-do-funcall-1 'undocumented t)
306
307 (defun command-line-do-eval (arg)
308   "Evaluate the lisp form.  Quote it carefully.
309 <form>"
310   (eval (read (pop command-line-args-left))))
311
312 (defun command-line-do-load (arg)
313   "Load the named file of Lisp code into XEmacs.
314 <file>"
315   (let ((file (pop command-line-args-left)))
316     ;; Take file from default dir if it exists there;
317     ;; otherwise let `load' search for it.
318     (if (file-exists-p (expand-file-name file))
319         (setq file (expand-file-name file)))
320     (load file nil t)))
321
322 (defun command-line-do-insert (arg)
323   "Insert file into the current buffer.
324 <file>"
325   (insert-file-contents (pop command-line-args-left)))
326
327 (defun command-line-do-kill (arg)
328   "Exit XEmacs."
329   (kill-emacs t))
330
331 (defun command-line-do-version (arg)
332   "Print version info and exit."
333   (princ (concat (emacs-version) "\n"))
334   (kill-emacs 0))
335
336 \f
337 ;;; Processing the command line and loading various init files
338
339 (defun early-error-handler (&rest debugger-args)
340   "You should probably not be using this."
341   ;; Used as the debugger during XEmacs initialization; if an error occurs,
342   ;; print some diagnostics, and kill XEmacs.
343
344   ;; output the contents of the warning buffer, since it won't be seen
345   ;; otherwise.
346   ;; #### kludge!  The call to Feval forces the pending warnings to
347   ;; get output.  There definitely needs to be a better way.
348   (let ((buffer (eval (get-buffer-create "*Warnings*"))))
349     (princ (buffer-substring (point-min buffer) (point-max buffer) buffer)
350            'external-debugging-output))
351
352   (let ((string "Initialization error")
353         (error (nth 1 debugger-args))
354         (debug-on-error nil)
355         (stream 'external-debugging-output))
356     (if (null error)
357         (princ string stream)
358       (princ (concat "\n" string ": ") stream)
359       (condition-case ()
360           (display-error error stream)
361         (error (princ "<<< error printing error message >>>" stream)))
362       (princ "\n" stream)
363       (if (memq (car-safe error) '(void-function void-variable))
364           (princ "
365         This probably means that XEmacs is picking up an old version of
366         the lisp library, or that some .elc files are not up-to-date.\n"
367                  stream)))
368     (when (not suppress-early-error-handler-backtrace)
369       (let ((print-length 1000)
370             (print-level 1000)
371             (print-escape-newlines t)
372             (print-readably nil))
373         (when (getenv "EMACSLOADPATH")
374           (princ (format "\n$EMACSLOADPATH is %s" (getenv "EMACSLOADPATH"))
375                  stream))
376         (princ (format "\nexec-directory is %S" exec-directory) stream)
377         (princ (format "\ndata-directory is %S" data-directory) stream)
378         (princ (format "\ndata-directory-list is %S" data-directory-list) stream)
379         (princ (format "\ndoc-directory is %S" doc-directory) stream)
380         (princ (format "\nload-path is %S" load-path) stream)
381         (princ "\n\n" stream)))
382     (when (not suppress-early-error-handler-backtrace)
383       (backtrace stream t)))
384   (if (fboundp 'mswindows-message-box)
385       (mswindows-message-box "Initialization error"))
386   (kill-emacs -1))
387
388 (defun normal-top-level ()
389   (if command-line-processed
390       (message "Back to top level.")
391     (setq command-line-processed t)
392     ;; Canonicalize HOME (PWD is canonicalized by init_buffer in buffer.c)
393     (let ((value (user-home-directory)))
394       (if (and value
395                (< (length value) (length default-directory))
396                (equal (file-attributes default-directory)
397                       (file-attributes value)))
398           (setq default-directory (file-name-as-directory value))))
399     (setq default-directory (abbreviate-file-name default-directory))
400     (initialize-xemacs-paths)
401
402     (startup-set-invocation-environment)
403
404     (let ((debug-paths (or debug-paths
405                            (and (getenv "EMACSDEBUGPATHS")
406                                 t))))
407
408       (setq emacs-roots (paths-find-emacs-roots invocation-directory
409                                                 invocation-name))
410
411       (if debug-paths
412           (princ (format "emacs-roots:\n%S\n" emacs-roots)
413                  'external-debugging-output))
414
415       (if (null emacs-roots)
416           (startup-find-roots-warning))
417       (startup-setup-paths emacs-roots
418                            user-init-directory
419                            inhibit-early-packages
420                            inhibit-site-lisp
421                            debug-paths)
422       (startup-setup-paths-warning))
423
424     (when (and (not inhibit-autoloads)
425                lisp-directory)
426       (load (expand-file-name (file-name-sans-extension autoload-file-name)
427                               lisp-directory) nil t)
428       (if (featurep 'utf-2000)
429           (load (expand-file-name
430                  (file-name-sans-extension autoload-file-name)
431                  (expand-file-name "utf-2000" lisp-directory))
432                 nil t)))
433
434     (if (not inhibit-autoloads)
435         (progn
436           (if (not inhibit-early-packages)
437               (packages-load-package-auto-autoloads early-package-load-path))
438           (packages-load-package-auto-autoloads late-package-load-path)
439           (packages-load-package-auto-autoloads last-package-load-path)))
440
441     (let (error-data)
442       (condition-case data
443           (command-line)
444         ;; catch non-error signals, especially quit
445         (t (setq error-data data)))
446       ;; Do this again, in case the init file defined more abbreviations.
447       (setq default-directory (abbreviate-file-name default-directory))
448       ;; Specify the file for recording all the auto save files of
449       ;; this session.  This is used by recover-session.
450       (if auto-save-list-file-prefix
451           (setq auto-save-list-file-name
452                 (expand-file-name
453                  (format "%s%d-%s"
454                          auto-save-list-file-prefix
455                          (emacs-pid)
456                          (system-name)))))
457       (run-hooks 'emacs-startup-hook)
458       (and term-setup-hook
459            (run-hooks 'term-setup-hook))
460       (setq term-setup-hook nil)
461       ;;      ;; Modify the initial frame based on what the init file puts into
462       ;;      ;; ...-frame-alist.
463       (frame-notice-user-settings)
464       ;;      ;;####FSFmacs junk
465       ;;      ;; Now we know the user's default font, so add it to the menu.
466       ;;      (if (fboundp 'font-menu-add-default)
467       ;;          (font-menu-add-default))
468       (when window-setup-hook
469         (run-hooks 'window-setup-hook))
470       (setq window-setup-hook nil)
471       (if error-data
472           ;; re-signal, and don't allow continuation as that will probably
473           ;; wipe out the user's .emacs if she hasn't migrated yet!
474           (signal-error (car error-data) (cdr error-data))))
475
476     (if load-user-init-file-p
477         (maybe-migrate-user-init-file))
478     ;; FSF calls precompute-menubar-bindings.  We don't mix menubars
479     ;; and keymaps.
480     ))
481
482 (defun command-line-early (args)
483   ;; This processes those switches which need to be processed before
484   ;; starting up the window system.
485
486   (setq command-line-default-directory default-directory)
487
488   ;; See if we should import version-control from the environment variable.
489   (let ((vc (getenv "VERSION_CONTROL")))
490     (cond ((eq vc nil))                 ;don't do anything if not set
491           ((or (string= vc "t")
492                (string= vc "numbered"))
493            (setq version-control t))
494           ((or (string= vc "nil")
495                (string= vc "existing"))
496            (setq version-control nil))
497           ((or (string= vc "never")
498                (string= vc "simple"))
499            (setq version-control 'never))))
500
501   ;;####FSFmacs
502   ;;  (if (let ((ctype
503   ;;         ;; Use the first of these three envvars that has a nonempty value.
504   ;;         (or (let ((string (getenv "LC_ALL")))
505   ;;               (and (not (equal string "")) string))
506   ;;             (let ((string (getenv "LC_CTYPE")))
507   ;;               (and (not (equal string "")) string))
508   ;;             (let ((string (getenv "LANG")))
509   ;;               (and (not (equal string "")) string)))))
510   ;;    (and ctype
511   ;;         (string-match iso-8859-1-locale-regexp ctype)))
512   ;;      (progn
513   ;;    (standard-display-european t)
514   ;;    (require 'iso-syntax)))
515
516   (setq load-user-init-file-p (not (noninteractive)))
517
518   ;; Allow (at least) these arguments anywhere in the command line
519   (let ((new-args nil)
520         (arg      nil))
521     (while args
522       (setq arg (pop args))
523       (cond
524        ((or (string= arg "-q")
525             (string= arg "-no-init-file"))
526         (setq load-user-init-file-p nil))
527        ((string= arg "-no-site-file")
528         (setq site-start-file nil))
529        ((or (string= arg "-no-early-packages")
530             (string= arg "--no-early-packages"))
531         (setq inhibit-early-packages t))
532        ((or (string= arg "-vanilla")
533             (string= arg "--vanilla")
534             ;; Some work on this one already done in emacs.c.
535             (string= arg "-no-autoloads")
536             (string= arg "--no-autoloads"))
537         (setq load-user-init-file-p nil
538               site-start-file nil))
539        ((string= arg "-user-init-file")
540         (setq user-init-file (pop args)))
541        ((string= arg "-user-init-directory")
542         (setq user-init-directory (file-name-as-directory (pop args))))
543        ((or (string= arg "-u")
544             (string= arg "-user"))
545         (let* ((user (pop args))
546                (home-user (concat "~" user)))
547           (setq user-init-directory (file-name-as-directory
548                                      (paths-construct-path
549                                       (list home-user user-init-directory-base))))
550           (setq user-init-file
551                 (find-user-init-file user-init-directory home-user))
552           (setq custom-file
553                 (make-custom-file-name user-init-file))))
554        ((string= arg "-debug-init")
555         (setq init-file-debug t))
556        ((string= arg "-unmapped")
557         (setq initial-frame-unmapped-p t))
558        ((or (string= arg "-debug-paths")
559             (string= arg "--debug-paths"))
560         t)
561        ((or (string= arg "--") (string= arg "-"))
562         (while args
563           (push (pop args) new-args)))
564        (t (push arg new-args))))
565
566     ;; obsolete, initialize for backward compatibility
567     (setq init-file-user (and load-user-init-file-p ""))
568
569     (nreverse new-args)))
570
571 (defconst initial-scratch-message "\
572 ;; This buffer is for notes you don't want to save, and for Lisp evaluation.
573 ;; If you want to create a file, first visit that file with C-x C-f,
574 ;; then enter the text in that file's own buffer.
575
576 "
577   "Initial message displayed in *scratch* buffer at startup.
578 If this is nil, no message will be displayed.")
579
580 (defun command-line ()
581   (let ((command-line-args-left (cdr command-line-args)))
582
583     (let ((debugger 'early-error-handler)
584           (debug-on-error t))
585
586       ;; Process magic command-line switches like -q and -u.  Do this
587       ;; before creating the first frame because some of these switches
588       ;; may affect that.  I think it's ok to do this before establishing
589       ;; the X connection, and maybe someday things like -nw can be
590       ;; handled here instead of down in C.
591       (setq command-line-args-left (command-line-early command-line-args-left))
592
593       (when (eq system-type 'windows-nt)
594         (init-mswindows-at-startup))
595
596       ;; Setup the toolbar icon directory
597       (when (featurep 'toolbar)
598         (init-toolbar-location))
599
600       ;; Run the window system's init function.  tty is considered to be
601       ;; a type of window system for this purpose.  This creates the
602       ;; initial (non stdio) device.
603       (when (and initial-window-system (not noninteractive))
604         (funcall (intern (concat "init-"
605                                  (symbol-name initial-window-system)
606                                  "-win"))))
607
608       ;; When not in batch mode, this creates the first visible frame,
609       ;; and deletes the stdio device.
610       (frame-initialize))
611
612     ;; Reinitialize faces if necessary.  This function changes face if
613     ;; it is created during auto-autoloads loading.  Otherwise, it
614     ;; does nothing.
615     (startup-initialize-custom-faces)
616
617     ;;
618     ;; We have normality, I repeat, we have normality.  Anything you still
619     ;; can't cope with is therefore your own problem.  (And we don't need
620     ;; to kill XEmacs for it.)
621     ;;
622
623     ;;; Load init files.
624     (load-init-file)
625
626     (with-current-buffer (get-buffer "*scratch*")
627       (erase-buffer)
628       ;; (insert initial-scratch-message)
629       (set-buffer-modified-p nil)
630       (when (eq major-mode 'fundamental-mode)
631         (funcall initial-major-mode)))
632
633     ;; Load library for our terminal type.
634     ;; User init file can set term-file-prefix to nil to prevent this.
635     ;; Note that for any TTY's opened subsequently, the TTY init
636     ;; code will run this.
637     (when (and (eq 'tty (console-type))
638                (not (noninteractive)))
639       (load-terminal-library))
640
641     ;; Process the remaining args.
642     (command-line-1)
643
644     ;; it was turned on by default so that the warnings don't get displayed
645     ;; until after the splash screen.
646     (setq inhibit-warning-display nil)
647     ;; If -batch, terminate after processing the command options.
648     (when (noninteractive) (kill-emacs t))))
649
650 (defun load-terminal-library ()
651   (when term-file-prefix
652     (let ((term (getenv "TERM"))
653           hyphend)
654       (while (and term
655                   (not (load (concat term-file-prefix term) t t)))
656         ;; Strip off last hyphen and what follows, then try again
657         (if (setq hyphend (string-match "[-_][^-_]+\\'" term))
658             (setq term (substring term 0 hyphend))
659           (setq term nil))))))
660
661 (defun find-user-init-directory-init-file (&optional init-directory)
662   "Determine the user's init file if in the init directory."
663   (let ((init-directory (or init-directory user-init-directory)))
664     (catch 'found
665       (dolist (file user-init-file-base-list)
666         (let ((expanded (expand-file-name file init-directory)))
667           (when (file-readable-p expanded)
668             (throw 'found expanded)))))))
669
670 (defun find-user-home-directory-init-file (&optional home-directory)
671   "Determine the user's init file if in the home directory."
672   (let ((home-directory (or home-directory "~")))
673     (catch 'found
674       (dolist (file user-home-init-file-base-list)
675         (let ((expanded (expand-file-name file home-directory)))
676           (when (file-readable-p expanded)
677             (throw 'found expanded))))
678       nil)))
679
680 (defun find-user-init-file (&optional init-directory home-directory)
681   "Determine the user's init file."
682   (if load-home-init-file
683       (find-user-home-directory-init-file home-directory)
684     (or (find-user-init-directory-init-file init-directory)
685         (find-user-home-directory-init-file home-directory))))
686
687 (defun maybe-migrate-user-init-file ()
688   "Ask user if she wants to migrate the init file(s) to new location."
689   (if (and (not load-home-init-file)
690            (not (find-user-init-directory-init-file user-init-directory))
691            (stringp user-init-file)
692            (file-readable-p user-init-file))
693       (if (with-output-to-temp-buffer (help-buffer-name nil)
694             (progn
695               (princ "XEmacs recommends that the initialization code in
696 ")
697               (princ user-init-file)
698               (princ "
699 be migrated to the ")
700               (princ user-init-directory)
701               (princ " directory.  XEmacs can
702 perform the migration automatically.
703
704 After the migration, init.el/init.elc holds user-written
705 initialization code.  Moreover the customize settings will be in
706 custom.el.
707
708 You can undo the migration at any time with
709 M-x maybe-unmigrate-user-init-file.
710
711 If you choose not to do this now, XEmacs will not ask you this
712 question in the future.  However, you can still make XEmacs
713 perform the migration at any time with M-x migrate-user-init-file.")
714               (show-temp-buffer-in-current-frame standard-output)
715               (yes-or-no-p-minibuf (concat "Migrate init file to "
716                                            user-init-directory
717                                            "? "))))
718
719           (let ((backup (migrate-user-init-file)))
720             (with-output-to-temp-buffer (help-buffer-name nil)
721               (progn
722               (princ "The initialization code has now been migrated to the ")
723               (princ user-init-directory)
724               (princ "directory.
725
726 For backwards compatibility with, for example, older versions of XEmacs,
727 XEmacs can create a special old-style .emacs file in your home
728 directory which will load the relocated initialization code.")
729               (if backup
730                   (progn
731                     (princ "\nMoreover, a backup of your old .emacs file was created as\n")
732                     (princ backup)
733                     (princ ".\n")))
734               (show-temp-buffer-in-current-frame standard-output)
735               (maybe-create-compatibility-dot-emacs))))
736         (customize-save-variable 'load-home-init-file t))))
737
738 (defun maybe-create-compatibility-dot-emacs ()
739   "Ask user if she wants to create a .emacs compatibility file."
740   (if (yes-or-no-p-minibuf "Create compatibility .emacs? ")
741       (create-compatibility-dot-emacs)))
742
743 (defun migrate-user-init-file ()
744   "Migrate the init file from the home directory.
745 Return the name of backup file, if one was created."
746   (interactive)
747   (if (not (file-exists-p user-init-directory))
748       (progn
749         (message "Creating %s directory..." user-init-directory)
750         (make-directory user-init-directory)))
751   (message "Migrating custom file...")
752   (let* ((backup (concat user-init-file ".backup"))
753          (backup-p
754           (and (not (file-exists-p backup))
755                (progn
756                  (copy-file user-init-file backup)
757                  t))))
758     (customize-set-value 'load-home-init-file nil)
759     (custom-migrate-custom-file (make-custom-file-name user-init-file
760                                                        'force-new))
761     (message "Moving init file...")
762     (let ((new-user-init-file (expand-file-name user-init-file-base
763                                                 user-init-directory)))
764       (rename-file user-init-file new-user-init-file)
765       (setq user-init-file new-user-init-file))
766     (message "Migration done.")
767     (and backup-p backup)))
768
769 (defun create-compatibility-dot-emacs ()
770   "Create .emacs compatibility file for migrated setup."
771   (message "Creating .emacs compatibility file.")
772   (with-temp-file (expand-file-name ".emacs" "~")
773     (insert ";;; XEmacs backwards compatibility file\n")
774     (insert "(setq user-init-file\n")
775     (insert "      (expand-file-name \"init.el\"\n")
776     (insert "                   (expand-file-name \".xemacs\" \"~\")))\n")
777     (insert "(setq custom-file\n")
778     (insert "      (expand-file-name \"custom.el\"\n")
779     (insert "                   (expand-file-name \".xemacs\" \"~\")))\n")
780     (insert "\n")
781     (insert "(load-file user-init-file)\n")
782     (insert "(load-file custom-file)"))
783   (message "Created .emacs compatibility file."))
784
785 (defun maybe-unmigrate-user-init-file ()
786   "Possibly unmigrate the user's init and custom files."
787   (interactive)
788   (let ((dot-emacs-file-name (expand-file-name ".emacs" "~")))
789     (if (and (not load-home-init-file)
790              (or (not (file-exists-p dot-emacs-file-name))
791                  (yes-or-no-p-minibuf (concat "Overwrite " dot-emacs-file-name
792                                               "? "))))
793       (unmigrate-user-init-file dot-emacs-file-name))))
794
795 (defun unmigrate-user-init-file (&optional target-file-name)
796   "Unmigrate the user's init and custom files."
797   (interactive)
798   (let ((target-file-name
799          (or target-file-name (expand-file-name ".emacs" "~"))))
800     (rename-file user-init-file target-file-name 'ok-if-already-exists)
801     (setq user-init-file target-file-name)
802     (let ((old-custom-file custom-file))
803       (custom-migrate-custom-file target-file-name)
804       (customize-save-variable 'load-home-init-file t)
805       (delete-file old-custom-file))))
806
807 (defun load-user-init-file ()
808   "This function actually reads the init file."
809   (if (not user-init-file)
810       (setq user-init-file
811             (find-user-init-file user-init-directory)))
812   (if (not custom-file)
813       (setq custom-file (make-custom-file-name user-init-file)))
814   ;; #### should test load-user-init-file-p here, not in load-init-file
815   ;; see comment there
816   (if (and user-init-file
817            (file-readable-p user-init-file))
818       (load user-init-file t t t))
819   (if (and custom-file
820            (or (not user-init-file)
821                (not (string= custom-file user-init-file)))
822            (file-readable-p custom-file))
823       (load custom-file t t t))
824   (unless inhibit-default-init
825     (let ((inhibit-startup-message nil))
826       ;; Users are supposed to be told their rights.
827       ;; (Plus how to get help and how to undo.)
828       ;; Don't you dare turn this off for anyone except yourself.
829       (load "default" t t))))
830
831 ;;; Load user's init file and default ones.
832 (defun load-init-file ()
833   (run-hooks 'before-init-hook)
834
835   ;; Run the site-start library if it exists.  The point of this file is
836   ;; that it is run before .emacs.  There is no point in doing this after
837   ;; .emacs; that is useless.
838   (when site-start-file
839     (load site-start-file t t))
840
841   ;; Sites should not disable this.  Only individuals should disable
842   ;; the startup message.
843   (setq inhibit-startup-message nil)
844
845   (let (debug-on-error-from-init-file
846         debug-on-error-should-be-set
847         (debug-on-error-initial
848          (if (eq init-file-debug t) 'startup init-file-debug)))
849     (let ((debug-on-error debug-on-error-initial))
850       ;; #### I believe this test is incorrect, it leads to custom-file
851       ;; (at least) being undefined
852       (if (and load-user-init-file-p init-file-debug)
853           (progn
854             ;; Do this without a condition-case if the user wants to debug.
855             (load-user-init-file))
856         (condition-case error
857             (progn
858               ;; #### probably incorrect, see comment above
859               (if load-user-init-file-p
860                   (load-user-init-file))
861               (setq init-file-had-error nil))
862           (error
863            (message "Error in init file: %s" (error-message-string error))
864            (display-warning 'initialization
865              (format "\
866 An error has occurred while loading %s:
867
868 %s
869
870 To ensure normal operation, you should investigate the cause of the error
871 in your initialization file and remove it.  Use the `-debug-init' option
872 to XEmacs to view a complete error backtrace."
873                      user-init-file (error-message-string error))
874              'error)
875            (setq init-file-had-error t))))
876       ;; If we can tell that the init file altered debug-on-error,
877       ;; arrange to preserve the value that it set up.
878       (or (eq debug-on-error debug-on-error-initial)
879           (setq debug-on-error-should-be-set t
880                 debug-on-error-from-init-file debug-on-error)))
881     (when debug-on-error-should-be-set
882       (setq debug-on-error debug-on-error-from-init-file)))
883
884   (setq init-file-loaded t)
885
886   ;; Do this here in case the init file sets mail-host-address.
887   ;; Don't do this here unless noninteractive, it is frequently wrong. -sb
888   ;; (or user-mail-address
889   (when noninteractive
890     (setq user-mail-address (concat (user-login-name) "@"
891                                     (or mail-host-address
892                                         (system-name)))))
893
894   (run-hooks 'after-init-hook)
895   nil)
896
897 (defun load-options-file (filename)
898   "Load the file of saved options (from the Options menu) called FILENAME.
899 Currently this does nothing but call `load', but it might be redefined
900 in the future to support automatically converting older options files to
901 a new format, when variables have changed, etc."
902   (load filename))
903
904 (defun command-line-1 ()
905   (cond
906    ((null command-line-args-left)
907     (unless noninteractive
908       ;; If there are no switches to process, run the term-setup-hook
909       ;; before displaying the copyright notice; there may be some need
910       ;; to do it before doing any output.  If we're not going to
911       ;; display a copyright notice (because other options are present)
912       ;; then this is run after those options are processed.
913       (run-hooks 'term-setup-hook)
914       ;; Don't let the hook be run twice.
915       (setq term-setup-hook nil)
916
917       ;; Don't clobber a non-scratch buffer if init file
918       ;; has selected it.
919       (when (string= (buffer-name) "*scratch*")
920         (unless (or inhibit-startup-message
921                     (input-pending-p))
922           (let (tmout circ-tmout)
923             (unwind-protect
924                 ;; Guts of with-timeout
925                 (catch 'tmout
926                   (setq tmout (add-timeout startup-message-timeout
927                                            (lambda (ignore)
928                                              (condition-case nil
929                                                  (throw 'tmout t)
930                                                (error nil)))
931                                            nil))
932                   (setq circ-tmout (display-splash-frame))
933                   (or nil;; (pos-visible-in-window-p (point-min))
934                       (goto-char (point-min)))
935                   (sit-for 0)
936                   (setq unread-command-event (next-command-event)))
937               (when tmout (disable-timeout tmout))
938               (when circ-tmout (disable-timeout circ-tmout)))))
939         (with-current-buffer (get-buffer "*scratch*")
940           ;; In case the XEmacs server has already selected
941           ;; another buffer, erase the one our message is in.
942           (erase-buffer)
943           (when (stringp initial-scratch-message)
944             (insert initial-scratch-message))
945           (set-buffer-modified-p nil)))))
946
947    (t
948     ;; Command-line-options exist
949     (let ((dir command-line-default-directory)
950           (file-count 0)
951           (line nil)
952           (end-of-options nil)
953           file-p arg tem)
954       (while command-line-args-left
955         (setq arg (pop command-line-args-left))
956         (cond
957          (end-of-options
958           (setq file-p t))
959          ((setq tem (when (eq (aref arg 0) ?-)
960                       (or (assoc arg command-switch-alist)
961                           (assoc (substring arg 1)
962                                  command-switch-alist))))
963           (funcall (cdr tem) arg))
964          ((string-match "\\`\\+[0-9]+\\'" arg)
965           (setq line (string-to-int arg)))
966          ;; "- file" means don't treat "file" as a switch
967          ;;  ("+0 file" has the same effect; "-" added
968          ;;   for unixoidiality).
969          ;; This is worthless; the `unixoid' way is "./file". -jwz
970          ((or (string= arg "-") (string= arg "--"))
971           (setq end-of-options t))
972          (t
973           (setq file-p t)))
974
975         (when file-p
976           (setq file-p nil)
977           (incf file-count)
978           (setq arg (expand-file-name arg dir))
979           (cond
980            ((= file-count 1)
981             (find-file arg))
982            (noninteractive (find-file arg))
983            (t (find-file-other-window arg)))
984           (when line
985             (goto-line line)
986             (setq line nil))))))))
987
988 (defvar startup-presentation-hack-keymap
989   (let ((map (make-sparse-keymap)))
990     (set-keymap-name map 'startup-presentation-hack-keymap)
991     (define-key map '[button1] 'startup-presentation-hack)
992     (define-key map '[button2] 'startup-presentation-hack)
993     map)
994   "Putting yesterday in the future tomorrow.")
995
996 (defun startup-presentation-hack ()
997   (interactive)
998   (let ((e last-command-event))
999     (and (button-press-event-p e)
1000          (setq e (extent-at (event-point e)
1001                             (event-buffer e)
1002                             'startup-presentation-hack))
1003          (setq e (extent-property e 'startup-presentation-hack))
1004          (if (consp e)
1005              (apply (car e) (cdr e))
1006            (while (keymapp (indirect-function e))
1007              (let ((map e)
1008                    (overriding-local-map (indirect-function e)))
1009                (setq e (read-key-sequence
1010                         (let ((p (keymap-prompt map t)))
1011                           (cond ((symbolp map)
1012                                  (if p
1013                                      (format "%s %s " map p)
1014                                    (format "%s " map)))
1015                                 (p)
1016                                 (t
1017                                  (prin1-to-string map))))))
1018                (if (and (button-release-event-p (elt e 0))
1019                         (null (key-binding e)))
1020                    (setq e map)         ; try again
1021                  (setq e (key-binding e)))))
1022            (call-interactively e)))))
1023
1024 (defun startup-presentation-hack-help (e)
1025   (setq e (extent-property e 'startup-presentation-hack))
1026   (if (consp e)
1027       (format "Evaluate %S" e)
1028     (symbol-name e)))
1029
1030 (defun splash-frame-present-hack (e v)
1031   ;;   (set-extent-property e 'mouse-face 'highlight)
1032   ;;   (set-extent-property e 'keymap
1033   ;;                           startup-presentation-hack-keymap)
1034   ;;   (set-extent-property e 'startup-presentation-hack v)
1035   ;;   (set-extent-property e 'help-echo
1036   ;;                           'startup-presentation-hack-help)
1037   )
1038
1039 (defun splash-hack-version-string ()
1040   (save-excursion
1041     (save-restriction
1042       (goto-char (point-min))
1043       (re-search-forward "^XEmacs" nil t)
1044       (narrow-to-region (point-at-bol) (point-at-eol))
1045       (goto-char (point-min))
1046       (when (re-search-forward " \\[Lucid\\]" nil t)
1047         (delete-region (match-beginning 0) (match-end 0)))
1048       (when (re-search-forward "[^(][^)]*-[^)]*-" nil t)
1049         (delete-region (1+ (match-beginning 0)) (match-end 0))
1050         (insert "("))
1051       (goto-char (point-max))
1052       (search-backward " " nil t)
1053       (when (search-forward "." nil t)
1054         (delete-region (1- (point)) (point-max))))))
1055
1056 (defun splash-frame-present (l)
1057   (cond ((stringp l)
1058          (insert l))
1059         ((eq (car-safe l) 'face)
1060          ;; (face name string)
1061          (let ((p (point)))
1062            (splash-frame-present (elt l 2))
1063            (if (fboundp 'set-extent-face)
1064                (set-extent-face (make-extent p (point))
1065                                 (elt l 1)))))
1066         ((eq (car-safe l) 'key)
1067          (let* ((c (elt l 1))
1068                 (p (point))
1069                 (k (where-is-internal c nil t)))
1070            (insert (if k (key-description k)
1071                      (format "M-x %s" c)))
1072            (if (fboundp 'set-extent-face)
1073                (let ((e (make-extent p (point))))
1074                  (set-extent-face e 'bold)
1075                  (splash-frame-present-hack e c)))))
1076         ((eq (car-safe l) 'funcall)
1077          ;; (funcall (fun . args) string)
1078          (let ((p (point)))
1079            (splash-frame-present (elt l 2))
1080            (if (fboundp 'set-extent-face)
1081                (splash-frame-present-hack (make-extent p (point))
1082                                           (elt l 1)))))
1083         ((consp l)
1084          (mapcar 'splash-frame-present l))
1085         (t
1086          (error "WTF!?"))))
1087
1088 (defun startup-center-spaces (glyph)
1089   ;; Return the number of spaces to insert in order to center
1090   ;; the given glyph (may be a string or a pixmap).
1091   ;; Assume spaces are as wide as avg-pixwidth.
1092   ;; Won't be quite right for proportional fonts, but it's the best we can do.
1093   ;; Maybe the new redisplay will export something a glyph-width function.
1094   ;;; #### Yes, there is a glyph-width function but it isn't quite what
1095   ;;; #### this was expecting.  Or is it?
1096   ;; (An alternate way to get avg-pixwidth would be to use x-font-properties
1097   ;; and calculate RESOLUTION_X * AVERAGE_WIDTH / 722.7, but it's no better.)
1098
1099   ;; This function is used in about.el too.
1100   (let* ((avg-pixwidth     (round (/ (frame-pixel-width) (frame-width))))
1101          (fill-area-width  (* avg-pixwidth (- fill-column left-margin)))
1102          (glyph-pixwidth   (cond ((stringp glyph)
1103                                   (* avg-pixwidth (length glyph)))
1104                                  ;; #### the pixmap option should be removed
1105                                  ;;((pixmapp glyph)
1106                                  ;; (pixmap-width glyph))
1107                                  ((glyphp glyph)
1108                                   (glyph-width glyph))
1109                                  (t
1110                                   (error "startup-center-spaces: bad arg")))))
1111     (+ left-margin
1112        (round (/ (/ (- fill-area-width glyph-pixwidth) 2) avg-pixwidth)))))
1113
1114 (defun splash-frame-body ()
1115   `[((face (blue bold underline)
1116            "\nDistribution, copying license, warranty:\n\n")
1117      "Please visit the XEmacs website at http://www.xemacs.org !\n\n"
1118      ,@(if (featurep 'sparcworks)
1119            `( "\
1120 Sun provides support for the WorkShop/XEmacs integration package only.
1121 All other XEmacs packages are provided to you \"AS IS\".\n"
1122               ,@(let ((lang (or (getenv "LC_ALL") (getenv "LC_MESSAGES")
1123                                 (getenv "LANG"))))
1124                   (if (and
1125                        (not (featurep 'mule)) ;; Already got mule?
1126                        ;; No Mule support on tty's yet
1127                        (not (eq 'tty (console-type)))
1128                        lang ;; Non-English locale?
1129                        (not (string= lang "C"))
1130                        (not (string-match "^en" lang))
1131                        ;; Comes with Sun WorkShop
1132                        (locate-file "xemacs-mule" exec-path))
1133                       '( "\
1134 This version of XEmacs has been built with support for Latin-1 languages only.
1135 To handle other languages you need to run a Multi-lingual (`Mule') version of
1136 XEmacs, by either running the command `xemacs-mule', or by using the X resource
1137 `ESERVE*defaultXEmacsPath: xemacs-mule' when starting XEmacs from Sun WorkShop.
1138 \n")))))
1139      ((key describe-no-warranty)
1140       ": "(face (red bold) "XEmacs comes with ABSOLUTELY NO WARRANTY\n"))
1141      ((key describe-copying)
1142       ": conditions to give out copies of XEmacs\n")
1143      ((key describe-distribution)
1144       ": how to get the latest version\n")
1145      "\n--\n"
1146      (face italic "\
1147 Copyright (C) 1985-2001 Free Software Foundation, Inc.
1148 Copyright (C) 1990-1994 Lucid, Inc.
1149 Copyright (C) 1993-1997 Sun Microsystems, Inc. All Rights Reserved.
1150 Copyright (C) 1994-1996 Board of Trustees, University of Illinois
1151 Copyright (C) 1995-2001 Ben Wing
1152 Copyright (C) 1996-2002 MORIOKA Tomohiko
1153 "))
1154
1155     ((face (blue bold underline) "\nInformation, on-line help:\n\n")
1156      "XEmacs comes with plenty of documentation...\n\n"
1157      ,@(if (string-match "beta" emacs-version)
1158            `((key describe-beta)
1159              ": " (face (red bold)
1160                         "This is an Experimental version of XEmacs.\n"))
1161          `( "\n"))
1162      ((key xemacs-local-faq)
1163       ": read the XEmacs FAQ (a " (face underline "capital") " F!)\n")
1164      ((key help-with-tutorial)
1165       ": read the XEmacs tutorial (also available through the "
1166       (face bold "Help") " menu)\n")
1167      ((key help-command)
1168       ": get help on using XEmacs (also available through the "
1169       (face bold "Help") " menu)\n")
1170      ((key info) ": read the on-line documentation\n\n")
1171      ((key describe-project) ": read about the GNU project\n")
1172      ((key about-xemacs) ": see who's developing XEmacs\n"))
1173
1174     ((face (blue bold underline) "\nUseful stuff:\n\n")
1175      "Things that you should learn rather quickly...\n\n"
1176      ((key find-file) ": visit a file\n")
1177      ((key save-buffer) ": save changes\n")
1178      ((key advertised-undo) ": undo changes\n")
1179      ((key save-buffers-kill-emacs) ": exit XEmacs\n"))
1180     ])
1181
1182 ;; I really hate global variables, oh well.
1183 ;(defvar xemacs-startup-logo-function nil
1184 ;  "If non-nil, function called to provide the startup logo.
1185 ;This function should return an initialized glyph if it is used.")
1186
1187 ;; This will hopefully go away when gettext is functional.
1188 (defconst splash-frame-static-body
1189   `(,(emacs-version) "\n\n"
1190     (face italic "`C-' means the control key,`M-' means the meta key\n\n")))
1191
1192
1193 (defun circulate-splash-frame-elements (client-data)
1194   (with-current-buffer (aref client-data 2)
1195     (let ((buffer-read-only nil)
1196           (elements (aref client-data 3))
1197           (indice (aref client-data 0)))
1198       (goto-char (aref client-data 1))
1199       (delete-region (point) (point-max))
1200       (splash-frame-present (aref elements indice))
1201       (set-buffer-modified-p nil)
1202       (aset client-data 0
1203             (if (= indice (- (length elements) 1))
1204                 0
1205               (1+ indice )))
1206       )))
1207
1208 ;; #### This function now returns the (possibly nil) timeout circulating the
1209 ;; splash-frame elements
1210 (defun display-splash-frame ()
1211   (let ((logo xemacs-logo)
1212         (buffer-read-only nil)
1213         (cramped-p (eq 'tty (console-type))))
1214     (unless cramped-p (insert "\n"))
1215     (indent-to (startup-center-spaces logo))
1216     (set-extent-begin-glyph (make-extent (point) (point)) logo)
1217     ;;(splash-frame-present-hack (make-extent p (point)) 'about-xemacs))
1218     (insert "\n\n")
1219     (splash-frame-present splash-frame-static-body)
1220     (splash-hack-version-string)
1221     (goto-char (point-max))
1222     (let* ((after-change-functions nil) ; no font-lock, thank you
1223            (elements (splash-frame-body))
1224            (client-data `[ 1 ,(point) ,(current-buffer) ,elements ])
1225            tmout)
1226       (if (listp  elements) ;; A single element to display
1227           (splash-frame-present (splash-frame-body))
1228         ;; several elements to rotate
1229         (splash-frame-present (aref elements 0))
1230         (setq tmout (add-timeout splash-frame-timeout
1231                                  'circulate-splash-frame-elements
1232                                  client-data splash-frame-timeout)))
1233       (set-buffer-modified-p nil)
1234       tmout)))
1235
1236 ;;  (let ((present-file
1237 ;;         #'(lambda (f)
1238 ;;             (splash-frame-present
1239 ;;            (list 'funcall
1240 ;;                  (list 'find-file-other-window
1241 ;;                        (expand-file-name f data-directory))
1242 ;;                  f)))))
1243 ;;    (insert "For customization examples, see the files ")
1244 ;;    (funcall present-file "sample.emacs")
1245 ;;    (insert " and ")
1246 ;;    (funcall present-file "sample.Xdefaults")
1247 ;;    (insert (format "\nin the directory %s." data-directory)))
1248
1249 (defun startup-set-invocation-environment ()
1250   ;; XEmacs -- Steven Baur says invocation directory is nil if you
1251   ;; try to use XEmacs as a login shell.
1252   (or invocation-directory (setq invocation-directory default-directory))
1253   (setq invocation-directory
1254         ;; don't let /tmp_mnt/... get into the load-path or exec-path.
1255         (abbreviate-file-name invocation-directory)))
1256
1257 (defun startup-setup-paths (roots user-init-directory
1258                                   &optional
1259                                   inhibit-early-packages inhibit-site-lisp
1260                                   debug-paths)
1261   "Setup all the various paths.
1262 ROOTS is a list of plausible roots of the XEmacs directory hierarchy.
1263 If INHIBIT-PACKAGES is non-NIL, don't do packages.
1264 If INHIBIT-SITE-LISP is non-NIL, don't do site-lisp.
1265 If DEBUG-PATHS is non-NIL, print paths as they are detected.
1266 It's idempotent, so call this as often as you like!"
1267
1268   (apply #'(lambda (early late last)
1269              (setq early-packages (and (not inhibit-early-packages)
1270                                        early))
1271              (setq late-packages late)
1272              (setq last-packages last))
1273          (packages-find-packages
1274           roots
1275           (packages-compute-package-locations user-init-directory)))
1276
1277   (setq early-package-load-path (packages-find-package-load-path early-packages))
1278   (setq late-package-load-path (packages-find-package-load-path late-packages))
1279   (setq last-package-load-path (packages-find-package-load-path last-packages))
1280
1281   (if debug-paths
1282       (progn
1283         (princ (format "configure-package-path:\n%S\n" configure-package-path)
1284                'external-debugging-output)
1285         (princ (format "early-packages and early-package-load-path:\n%S\n%S\n"
1286                        early-packages early-package-load-path)
1287                'external-debugging-output)
1288         (princ (format "late-packages and late-package-load-path:\n%S\n%S\n"
1289                        late-packages late-package-load-path)
1290                'external-debugging-output)
1291         (princ (format "last-packages and last-package-load-path:\n%S\n%S\n"
1292                        last-packages last-package-load-path)
1293                'external-debugging-output)))
1294
1295   (setq lisp-directory (paths-find-lisp-directory roots))
1296
1297   (if debug-paths
1298       (princ (format "lisp-directory:\n%S\n" lisp-directory)
1299              'external-debugging-output))
1300
1301   (if (featurep 'mule)
1302       (progn
1303         (setq mule-lisp-directory
1304               (paths-find-mule-lisp-directory roots
1305                                               lisp-directory))
1306         (if debug-paths
1307             (princ (format "mule-lisp-directory:\n%S\n"
1308                            mule-lisp-directory)
1309                    'external-debugging-output)))
1310     (setq mule-lisp-directory '()))
1311
1312   (if (featurep 'utf-2000)
1313       (progn
1314         (setq utf-2000-lisp-directory
1315               (paths-find-utf-2000-lisp-directory roots
1316                                                   lisp-directory))
1317         (if debug-paths
1318             (princ (format "utf-2000-lisp-directory:\n%S\n"
1319                            utf-2000-lisp-directory)
1320                    'external-debugging-output)))
1321     (setq utf-2000-lisp-directory '()))
1322
1323   (setq site-directory (and (null inhibit-site-lisp)
1324                             (paths-find-site-lisp-directory roots)))
1325
1326   (if (and debug-paths (null inhibit-site-lisp))
1327       (princ (format "site-directory:\n%S\n" site-directory)
1328              'external-debugging-output))
1329
1330   (setq load-path (paths-construct-load-path roots
1331                                              early-package-load-path
1332                                              late-package-load-path
1333                                              last-package-load-path
1334                                              lisp-directory
1335                                              site-directory
1336                                              mule-lisp-directory
1337                                              utf-2000-lisp-directory))
1338
1339   (setq Info-directory-list
1340         (paths-construct-info-path roots
1341                                    early-packages late-packages last-packages))
1342
1343
1344   (if debug-paths
1345       (princ (format "Info-directory-list:\n%S\n" Info-directory-list)
1346              'external-debugging-output))
1347
1348   (setq exec-directory (paths-find-exec-directory roots))
1349
1350   (if debug-paths
1351       (princ (format "exec-directory:\n%s\n" exec-directory)
1352              'external-debugging-output))
1353
1354   (setq exec-path
1355         (paths-construct-exec-path roots exec-directory
1356                                    early-packages late-packages last-packages))
1357
1358   (if debug-paths
1359       (princ (format "exec-path:\n%S\n" exec-path)
1360              'external-debugging-output))
1361
1362   (setq doc-directory (paths-find-doc-directory roots))
1363
1364   (if debug-paths
1365       (princ (format "doc-directory:\n%S\n" doc-directory)
1366              'external-debugging-output))
1367
1368   (setq data-directory (paths-find-data-directory roots))
1369
1370   (if debug-paths
1371       (princ (format "data-directory:\n%S\n" data-directory)
1372              'external-debugging-output))
1373
1374   (setq data-directory-list (paths-construct-data-directory-list data-directory
1375                                                                  early-packages
1376                                                                  late-packages
1377                                                                  last-packages))
1378   (if debug-paths
1379       (princ (format "data-directory-list:\n%S\n" data-directory-list)
1380              'external-debugging-output)))
1381
1382 (defun startup-find-roots-warning ()
1383   (save-excursion
1384     (set-buffer (get-buffer-create " *warning-tmp*"))
1385     (erase-buffer)
1386     (buffer-disable-undo (current-buffer))
1387
1388     (insert "Couldn't find an obvious default for the root of the\n"
1389             "XEmacs hierarchy.")
1390
1391     (princ "\nWARNING:\n" 'external-debugging-output)
1392     (princ (buffer-string) 'external-debugging-output)))
1393
1394 (defun startup-setup-paths-warning ()
1395   (let ((warnings '()))
1396     (cond
1397      ((null (and lisp-directory exec-directory data-directory doc-directory
1398                  load-path))
1399       (save-excursion
1400         (set-buffer (get-buffer-create " *warning-tmp*"))
1401         (erase-buffer)
1402         (buffer-disable-undo (current-buffer))
1403         (if (null lisp-directory) (push "lisp-directory" warnings))
1404         (if (and (featurep 'mule)
1405                  (null mule-lisp-directory))
1406             (push "mule-lisp-directory" warnings))
1407         (if (and (featurep 'utf-2000)
1408                  (null utf-2000-lisp-directory))
1409             (push "utf-2000-lisp-directory" warnings))
1410         (if (null exec-directory) (push "exec-directory" warnings))
1411         (if (null data-directory) (push "data-directory" warnings))
1412         (if (null doc-directory)  (push "doc-directory"  warnings))
1413         (if (null load-path)      (push "load-path"      warnings))
1414
1415         (insert "Couldn't find obvious defaults for:\n")
1416         (while warnings
1417           (insert (car warnings) "\n")
1418           (setq warnings (cdr warnings)))
1419         (insert "Perhaps some directories don't exist, "
1420                 "or the XEmacs executable,\n" (concat invocation-directory
1421                                                      invocation-name)
1422                 "\nis in a strange place?")
1423
1424         (princ "\nWARNING:\n" 'external-debugging-output)
1425         (princ (buffer-string) 'external-debugging-output)
1426         (erase-buffer)
1427         t)))))
1428
1429 ;;; startup.el ends here