git.chise.org Git - chise/xemacs-chise.git.1/blob - 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
  47 (defconst inhibit-startup-message nil
  48   "*Non-nil inhibits the initial startup message.
  49 This is for use in your personal init file, once you are familiar
  50 with the contents of the startup message.")
  51
  52 ;; #### FSFmacs randomness
  53 ;;(defconst inhibit-startup-echo-area-message nil
  54 ;;  "*Non-nil inhibits the initial startup echo area message.
  55 ;;Inhibition takes effect only if your `.emacs' file contains
  56 ;;a line of this form:
  57 ;; (setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\")
  58 ;;If your `.emacs' file is byte-compiled, use the following form instead:
  59 ;; (eval '(setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\"))
  60 ;;Thus, someone else using a copy of your `.emacs' file will see
  61 ;;the startup message unless he personally acts to inhibit it.")
  62
  63 (defconst inhibit-default-init nil
  64   "*Non-nil inhibits loading the `default' library.")
  65
  66 (defvar command-line-args-left nil
  67   "List of command-line args not yet processed.") ; bound by `command-line'
  68
  69 (defvar command-line-default-directory nil
  70   "Default directory to use for command line arguments.
  71 This is normally copied from `default-directory' when XEmacs starts.")
  72
  73 (defvar before-init-hook nil
  74   "Functions to call after handling urgent options but before init files.
  75 The frame system uses this to open frames to display messages while
  76 XEmacs loads the user's initialization file.")
  77
  78 (defvar after-init-hook nil
  79   "*Functions to call after loading the init file (`.emacs').
  80 The call is not protected by a condition-case, so you can set `debug-on-error'
  81 in `.emacs', and put all the actual code on `after-init-hook'.")
  82
  83 (defvar term-setup-hook nil
  84   "*Functions to be called after loading terminal-specific Lisp code.
  85 See `run-hooks'.  This variable exists for users to set, so as to
  86 override the definitions made by the terminal-specific file.  XEmacs
  87 never sets this variable itself.")
  88
  89 (defvar keyboard-type nil
  90   "The brand of keyboard you are using.
  91 This variable is used to define the proper function and keypad keys
  92 for use under X.  It is used in a fashion analogous to the environment
  93 value TERM.")
  94
  95 (defvar window-setup-hook nil
  96   "Normal hook run to initialize window system display.
  97 XEmacs runs this hook after processing the command line arguments and loading
  98 the user's init file.")
  99
 100 (defconst initial-major-mode 'lisp-interaction-mode
 101   "Major mode command symbol to use for the initial *scratch* buffer.")
 102
 103 (defvar emacs-roots nil
 104   "List of plausible roots of the XEmacs hierarchy.")
 105
 106 (defvar init-file-user nil
 107   "Identity of user whose `.emacs' file is or was read.
 108 The value is nil if no init file is being used; otherwise, it may be either
 109 the null string, meaning that the init file was taken from the user that
 110 originally logged in, or it may be a string containing a user's name.
 111
 112 In either of the latter cases, `(concat \"~\" init-file-user \"/\")'
 113 evaluates to the name of the directory in which the `.emacs' file was
 114 searched for.
 115
 116 Setting `init-file-user' does not prevent Emacs from loading
 117 `site-start.el'.  The only way to do that is to use `--no-site-file'.")
 118
 119 ;; #### called `site-run-file' in FSFmacs
 120
 121 (defvar site-start-file (purecopy "site-start")
 122   "File containing site-wide run-time initializations.
 123 This file is loaded at run-time before `.emacs'.  It
 124 contains inits that need to be in place for the entire site, but
 125 which, due to their higher incidence of change, don't make sense to
 126 load into XEmacs' dumped image.  Thus, the run-time load order is:
 127
 128   1. file described in this variable, if non-nil;
 129   2. `.emacs';
 130   3. `/path/to/xemacs/lisp/default.el'.
 131
 132 Don't use the `site-start.el' file for things some users may not like.
 133 Put them in `default.el' instead, so that users can more easily
 134 override them.  Users can prevent loading `default.el' with the `-q'
 135 option or by setting `inhibit-default-init' in their own init files,
 136 but inhibiting `site-start.el' requires `--no-site-file', which
 137 is less convenient.")
 138
 139 ;;(defconst iso-8859-1-locale-regexp "8859[-_]?1"
 140 ;;  "Regexp that specifies when to enable the ISO 8859-1 character set.
 141 ;;We do that if this regexp matches the locale name
 142 ;;specified by the LC_ALL, LC_CTYPE and LANG environment variables.")
 143
 144 (defvar mail-host-address nil
 145   "*Name of this machine, for purposes of naming users.")
 146
 147 (defvar user-mail-address nil
 148   "*Full mailing address of this user.
 149 This is initialized based on `mail-host-address',
 150 after your init file is read, in case it sets `mail-host-address'.")
 151
 152 (defvar auto-save-list-file-prefix "~/.saves-"
 153   "Prefix for generating auto-save-list-file-name.
 154 Emacs's pid and the system name will be appended to
 155 this prefix to create a unique file name.")
 156
 157 (defvar init-file-debug nil)
 158
 159 (defvar init-file-had-error nil)
 160
 161 (defvar init-file-loaded nil
 162   "True after the user's init file has been loaded (or suppressed with -q).
 163 This will be true when `after-init-hook' is run and at all times
 164 after, and will not be true at any time before.")
 165
 166 (defvar initial-frame-unmapped-p nil)
 167
 168 \f
 169
 170 (defvar command-switch-alist
 171   (purecopy
 172    '(("-help"   . command-line-do-help)
 173      ("-version". command-line-do-version)
 174      ("-V"      . command-line-do-version)
 175      ("-funcall". command-line-do-funcall)
 176      ("-f"      . command-line-do-funcall)
 177      ("-e"      . command-line-do-funcall-1)
 178      ("-eval"   . command-line-do-eval)
 179      ("-load"   . command-line-do-load)
 180      ("-l"      . command-line-do-load)
 181      ("-insert" . command-line-do-insert)
 182      ("-i"      . command-line-do-insert)
 183      ("-kill"   . command-line-do-kill)
 184      ;; Options like +35 are handled specially.
 185      ;; Window-system, site, or package-specific code might add to this.
 186      ;; X11 handles its options by letting Xt remove args from this list.
 187      ))
 188   "Alist of command-line switches.
 189 Elements look like (SWITCH-STRING . HANDLER-FUNCTION).
 190 HANDLER-FUNCTION receives switch name as sole arg;
 191 remaining command-line args are in the variable `command-line-args-left'.")
 192
 193 ;;; default switches
 194 ;;; Note: these doc strings are semi-magical.
 195
 196 (defun command-line-do-help (arg)
 197   "Print the XEmacs usage message and exit."
 198   (let ((standard-output 'external-debugging-output))
 199     (princ (concat "\n" (emacs-version) "\n\n"))
 200     (princ
 201      (if (featurep 'x)
 202          (concat (emacs-name)
 203                  " accepts all standard X Toolkit command line options.\n"
 204                  "In addition, the")
 205        "The"))
 206     (princ " following options are accepted:
 207
 208   -t <device>           Use TTY <device> instead of the terminal for input
 209                         and output.  This implies the -nw option.
 210   -nw                   Inhibit the use of any window-system-specific
 211                         display code: use the current tty.
 212   -batch                Execute noninteractively (messages go to stderr).
 213   -debug-init           Enter the debugger if an error in the init file occurs.
 214   -unmapped             Do not map the initial frame.
 215   -no-site-file         Do not load the site-specific init file (site-start.el).
 216   -no-init-file         Do not load the user-specific init file (~/.emacs).
 217   -no-early-packages    Do not process early packages.
 218   -no-autoloads         Do not load global symbol files (auto-autoloads) at
 219                         startup.  Also implies `-vanilla'.
 220   -vanilla              Equivalent to -q -no-site-file -no-early-packages.
 221   -q                    Same as -no-init-file.
 222   -user <user>          Load user's init file instead of your own.
 223   -u <user>             Same as -user.\n")
 224    (let ((l command-switch-alist)
 225           (insert (lambda (&rest x)
 226                     (princ "  ")
 227                     (let ((len 2))
 228                       (while x
 229                         (princ (car x))
 230                         (incf len (length (car x)))
 231                         (setq x (cdr x)))
 232                       (when (>= len 24)
 233                         (terpri) (setq len 0))
 234                       (while (< len 24)
 235                         (princ " ")
 236                         (incf len))))))
 237       (while l
 238         (let ((name (car (car l)))
 239               (fn (cdr (car l)))
 240               doc arg cons)
 241           (cond
 242            ((and (symbolp fn) (get fn 'undocumented)) nil)
 243            (t
 244             (setq doc (documentation fn))
 245             (if (member doc '(nil "")) (setq doc "(undocumented)"))
 246             (cond ((string-match "\n\\(<.*>\\)\n?\\'" doc)
 247                    ;; Doc of the form "The frobber switch\n<arg1> <arg2>"
 248                    (setq arg (substring doc (match-beginning 1) (match-end 1))
 249                          doc (substring doc 0 (match-beginning 0))))
 250                   ((string-match "\n+\\'" doc)
 251                    (setq doc (substring doc 0 (match-beginning 0)))))
 252             (if (and (setq cons (rassq fn command-switch-alist))
 253                      (not (eq cons (car l))))
 254                 (setq doc (format "Same as %s." (car cons))))
 255             (if arg
 256                 (funcall insert name " " arg)
 257               (funcall insert name))
 258             (princ doc)
 259             (terpri))))
 260         (setq l (cdr l))))
 261     (princ (concat "\
 262   +N <file>             Start displaying <file> at line N.
 263
 264 Anything else is considered a file name, and is placed into a buffer for
 265 editing.
 266
 267 " (emacs-name) " has an online tutorial and manuals.  Type ^Ht (Control-h t) after
 268 starting XEmacs to run the tutorial.  Type ^Hi to enter the manual browser.
 269 Type ^H^H^H (Control-h Control-h Control-h) to get more help options.\n")
 270
 271     (kill-emacs 0))))
 272
 273 (defun command-line-do-funcall (arg)
 274   "Invoke the named lisp function with no arguments.
 275 <function>"
 276   (funcall (intern (pop command-line-args-left))))
 277 (fset 'command-line-do-funcall-1 'command-line-do-funcall)
 278 (put 'command-line-do-funcall-1 'undocumented t)
 279
 280 (defun command-line-do-eval (arg)
 281   "Evaluate the lisp form.  Quote it carefully.
 282 <form>"
 283   (eval (read (pop command-line-args-left))))
 284
 285 (defun command-line-do-load (arg)
 286   "Load the named file of Lisp code into XEmacs.
 287 <file>"
 288   (let ((file (pop command-line-args-left)))
 289     ;; Take file from default dir if it exists there;
 290     ;; otherwise let `load' search for it.
 291     (if (file-exists-p (expand-file-name file))
 292         (setq file (expand-file-name file)))
 293     (load file nil t)))
 294
 295 (defun command-line-do-insert (arg)
 296   "Insert file into the current buffer.
 297 <file>"
 298   (insert-file-contents (pop command-line-args-left)))
 299
 300 (defun command-line-do-kill (arg)
 301   "Exit XEmacs."
 302   (kill-emacs t))
 303
 304 (defun command-line-do-version (arg)
 305   "Print version info and exit."
 306   (princ (concat (emacs-version) "\n"))
 307   (kill-emacs 0))
 308
 309 \f
 310 ;;; Processing the command line and loading various init files
 311
 312 (defun early-error-handler (&rest debugger-args)
 313   "You should probably not be using this."
 314   ;; Used as the debugger during XEmacs initialization; if an error occurs,
 315   ;; print some diagnostics, and kill XEmacs.
 316
 317   ;; output the contents of the warning buffer, since it won't be seen
 318   ;; otherwise.
 319   ;; #### kludge!  The call to Feval forces the pending warnings to
 320   ;; get output.  There definitely needs to be a better way.
 321   (let ((buffer (eval (get-buffer-create "*Warnings*"))))
 322     (princ (buffer-substring (point-min buffer) (point-max buffer) buffer)
 323            'external-debugging-output))
 324
 325   (let ((string "Initialization error")
 326         (error (nth 1 debugger-args))
 327         (debug-on-error nil)
 328         (stream 'external-debugging-output))
 329     (if (null error)
 330         (princ string stream)
 331       (princ (concat "\n" string ": ") stream)
 332       (condition-case ()
 333           (display-error error stream)
 334         (error (princ "<<< error printing error message >>>" stream)))
 335       (princ "\n" stream)
 336       (if (memq (car-safe error) '(void-function void-variable))
 337           (princ "
 338         This probably means that XEmacs is picking up an old version of
 339         the lisp library, or that some .elc files are not up-to-date.\n"
 340                  stream)))
 341     (when (not suppress-early-error-handler-backtrace)
 342       (let ((print-length 1000)
 343             (print-level 1000)
 344             (print-escape-newlines t)
 345             (print-readably nil))
 346         (when (getenv "EMACSLOADPATH")
 347           (princ (format "\n$EMACSLOADPATH is %s" (getenv "EMACSLOADPATH"))
 348                  stream))
 349         (princ (format "\nexec-directory is %S" exec-directory) stream)
 350         (princ (format "\ndata-directory is %S" data-directory) stream)
 351         (princ (format "\ndata-directory-list is %S" data-directory-list) stream)
 352         (princ (format "\ndoc-directory is %S" doc-directory) stream)
 353         (princ (format "\nload-path is %S" load-path) stream)
 354         (princ "\n\n" stream)))
 355     (when (not suppress-early-error-handler-backtrace)
 356       (backtrace stream t)))
 357   (kill-emacs -1))
 358
 359 (defvar lock-directory)
 360 (defvar superlock-file)
 361
 362 (defun normal-top-level ()
 363   (if command-line-processed
 364       (message "Back to top level.")
 365     (setq command-line-processed t)
 366     ;; Canonicalize HOME (PWD is canonicalized by init_buffer in buffer.c)
 367     (unless (eq system-type 'vax-vms)
 368       (let ((value (user-home-directory)))
 369         (if (and value
 370                  (< (length value) (length default-directory))
 371                  (equal (file-attributes default-directory)
 372                         (file-attributes value)))
 373             (setq default-directory (file-name-as-directory value)))))
 374     (setq default-directory (abbreviate-file-name default-directory))
 375     (initialize-xemacs-paths)
 376
 377     (startup-set-invocation-environment)
 378
 379     (let ((debug-paths (or debug-paths
 380                            (and (getenv "EMACSDEBUGPATHS")
 381                                 t))))
 382
 383       (setq emacs-roots (paths-find-emacs-roots invocation-directory
 384                                                 invocation-name))
 385
 386       (if debug-paths
 387           (princ (format "emacs-roots:\n%S\n" emacs-roots)
 388                  'external-debugging-output))
 389
 390       (if (null emacs-roots)
 391           (startup-find-roots-warning)
 392         (startup-setup-paths emacs-roots
 393                              inhibit-early-packages
 394                              inhibit-site-lisp
 395                              debug-paths))
 396       (startup-setup-paths-warning))
 397
 398     (if (and (not inhibit-autoloads)
 399              lisp-directory)
 400         (load (expand-file-name (file-name-sans-extension autoload-file-name)
 401                                 lisp-directory) nil t))
 402
 403     (if (not inhibit-autoloads)
 404         (progn
 405           (if (not inhibit-early-packages)
 406               (packages-load-package-auto-autoloads early-package-load-path))
 407           (packages-load-package-auto-autoloads late-package-load-path)
 408           (packages-load-package-auto-autoloads last-package-load-path)))
 409
 410     (unwind-protect
 411         (command-line)
 412       ;; Do this again, in case .emacs defined more abbreviations.
 413       (setq default-directory (abbreviate-file-name default-directory))
 414       ;; Specify the file for recording all the auto save files of
 415       ;; this session.  This is used by recover-session.
 416       (setq auto-save-list-file-name
 417             (expand-file-name
 418              (format "%s%d-%s"
 419                      auto-save-list-file-prefix
 420                      (emacs-pid)
 421                      (system-name))))
 422       (run-hooks 'emacs-startup-hook)
 423       (and term-setup-hook
 424            (run-hooks 'term-setup-hook))
 425       (setq term-setup-hook nil)
 426       ;;      ;; Modify the initial frame based on what .emacs puts into
 427       ;;      ;; ...-frame-alist.
 428       (frame-notice-user-settings)
 429       ;;      ;;####FSFmacs junk
 430       ;;      ;; Now we know the user's default font, so add it to the menu.
 431       ;;      (if (fboundp 'font-menu-add-default)
 432       ;;          (font-menu-add-default))
 433       (when window-setup-hook
 434         (run-hooks 'window-setup-hook))
 435       (setq window-setup-hook nil))
 436     ;;####FSFmacs junk
 437     ;;      (or menubar-bindings-done
 438     ;;    (precompute-menubar-bindings))
 439     ))
 440
 441 ;;####FSFmacs junk
 442 ;;; Precompute the keyboard equivalents in the menu bar items.
 443 ;;(defun precompute-menubar-bindings ()
 444 ;;  (if (eq window-system 'x)
 445 ;;      (let ((submap (lookup-key global-map [menu-bar])))
 446 ;;      (while submap
 447 ;;        (and (consp (car submap))
 448 ;;             (symbolp (car (car submap)))
 449 ;;             (stringp (car-safe (cdr (car submap))))
 450 ;;             (keymapp (cdr (cdr (car submap))))
 451 ;;             (x-popup-menu nil (cdr (cdr (car submap)))))
 452 ;;        (setq submap (cdr submap))))))
 453
 454 (defun command-line-early (args)
 455   ;; This processes those switches which need to be processed before
 456   ;; starting up the window system.
 457
 458   (setq command-line-default-directory default-directory)
 459
 460   ;; See if we should import version-control from the environment variable.
 461   (let ((vc (getenv "VERSION_CONTROL")))
 462     (cond ((eq vc nil))                 ;don't do anything if not set
 463           ((or (string= vc "t")
 464                (string= vc "numbered"))
 465            (setq version-control t))
 466           ((or (string= vc "nil")
 467                (string= vc "existing"))
 468            (setq version-control nil))
 469           ((or (string= vc "never")
 470                (string= vc "simple"))
 471            (setq version-control 'never))))
 472
 473   ;;####FSFmacs
 474   ;;  (if (let ((ctype
 475   ;;         ;; Use the first of these three envvars that has a nonempty value.
 476   ;;         (or (let ((string (getenv "LC_ALL")))
 477   ;;               (and (not (equal string "")) string))
 478   ;;             (let ((string (getenv "LC_CTYPE")))
 479   ;;               (and (not (equal string "")) string))
 480   ;;             (let ((string (getenv "LANG")))
 481   ;;               (and (not (equal string "")) string)))))
 482   ;;    (and ctype
 483   ;;         (string-match iso-8859-1-locale-regexp ctype)))
 484   ;;      (progn
 485   ;;    (standard-display-european t)
 486   ;;    (require 'iso-syntax)))
 487
 488   ;; Figure out which user's init file to load,
 489   ;; either from the environment or from the options.
 490   (setq init-file-user (if (noninteractive) nil (user-login-name)))
 491   ;; If user has not done su, use current $HOME to find .emacs.
 492   (and init-file-user (string= init-file-user (user-real-login-name))
 493        (setq init-file-user ""))
 494
 495   ;; Allow (at least) these arguments anywhere in the command line
 496   (let ((new-args nil)
 497         (arg      nil))
 498     (while args
 499       (setq arg (pop args))
 500       (cond
 501        ((or (string= arg "-q")
 502             (string= arg "-no-init-file"))
 503         (setq init-file-user nil))
 504        ((string= arg "-no-site-file")
 505         (setq site-start-file nil))
 506        ((or (string= arg "-no-early-packages")
 507             (string= arg "--no-early-packages"))
 508         (setq inhibit-early-packages t))
 509        ((or (string= arg "-vanilla")
 510             (string= arg "--vanilla")
 511             ;; Some work on this one already done in emacs.c.
 512             (string= arg "-no-autoloads")
 513             (string= arg "--no-autoloads"))
 514         (setq init-file-user nil
 515               site-start-file nil))
 516        ((or (string= arg "-u")
 517             (string= arg "-user"))
 518         (setq init-file-user (pop args)))
 519        ((string= arg "-debug-init")
 520         (setq init-file-debug t))
 521        ((string= arg "-unmapped")
 522         (setq initial-frame-unmapped-p t))
 523        ((or (string= arg "-debug-paths")
 524             (string= arg "--debug-paths"))
 525         t)
 526        ((or (string= arg "--") (string= arg "-"))
 527         (while args
 528           (push (pop args) new-args)))
 529        (t (push arg new-args))))
 530
 531     (nreverse new-args)))
 532
 533 (defconst initial-scratch-message "\
 534 ;; This buffer is for notes you don't want to save, and for Lisp evaluation.
 535 ;; If you want to create a file, first visit that file with C-x C-f,
 536 ;; then enter the text in that file's own buffer.
 537
 538 "
 539   "Initial message displayed in *scratch* buffer at startup.
 540 If this is nil, no message will be displayed.")
 541
 542 (defun command-line ()
 543   (let ((command-line-args-left (cdr command-line-args)))
 544
 545     (let ((debugger 'early-error-handler)
 546           (debug-on-error t))
 547
 548       ;; Process magic command-line switches like -q and -u.  Do this
 549       ;; before creating the first frame because some of these switches
 550       ;; may affect that.  I think it's ok to do this before establishing
 551       ;; the X connection, and maybe someday things like -nw can be
 552       ;; handled here instead of down in C.
 553       (setq command-line-args-left (command-line-early command-line-args-left))
 554
 555       ;; Setup the toolbar icon directory
 556       (when (featurep 'toolbar)
 557         (init-toolbar-location))
 558
 559       ;; Run the window system's init function.  tty is considered to be
 560       ;; a type of window system for this purpose.  This creates the
 561       ;; initial (non stdio) device.
 562       (when (and initial-window-system (not noninteractive))
 563         (funcall (intern (concat "init-"
 564                                  (symbol-name initial-window-system)
 565                                  "-win"))))
 566
 567       ;; When not in batch mode, this creates the first visible frame,
 568       ;; and deletes the stdio device.
 569       (frame-initialize))
 570
 571     ;;
 572     ;; We have normality, I repeat, we have normality.  Anything you still
 573     ;; can't cope with is therefore your own problem.  (And we don't need
 574     ;; to kill XEmacs for it.)
 575     ;;
 576
 577     ;;; Load init files.
 578     (load-init-file)
 579
 580     (with-current-buffer (get-buffer "*scratch*")
 581       (erase-buffer)
 582       ;; (insert initial-scratch-message)
 583       (set-buffer-modified-p nil)
 584       (when (eq major-mode 'fundamental-mode)
 585         (funcall initial-major-mode)))
 586
 587     ;; Load library for our terminal type.
 588     ;; User init file can set term-file-prefix to nil to prevent this.
 589     ;; Note that for any TTY's opened subsequently, the TTY init
 590     ;; code will run this.
 591     (when (and (eq 'tty (console-type))
 592                (not (noninteractive)))
 593       (load-terminal-library))
 594
 595     ;; Process the remaining args.
 596     (command-line-1)
 597
 598     ;; it was turned on by default so that the warnings don't get displayed
 599     ;; until after the splash screen.
 600     (setq inhibit-warning-display nil)
 601     ;; If -batch, terminate after processing the command options.
 602     (when (noninteractive) (kill-emacs t))))
 603
 604 (defun load-terminal-library ()
 605   (when term-file-prefix
 606     (let ((term (getenv "TERM"))
 607           hyphend)
 608       (while (and term
 609                   (not (load (concat term-file-prefix term) t t)))
 610         ;; Strip off last hyphen and what follows, then try again
 611         (if (setq hyphend (string-match "[-_][^-_]+\\'" term))
 612             (setq term (substring term 0 hyphend))
 613           (setq term nil))))))
 614
 615 (defconst user-init-directory "/.xemacs/"
 616   "Directory where user-installed packages may go.")
 617 (define-obsolete-variable-alias
 618   'emacs-user-extension-dir
 619   'user-init-directory)
 620
 621 (defun load-user-init-file (init-file-user)
 622   "This function actually reads the init file, .emacs."
 623   (when init-file-user
 624 ;; purge references to init.el and options.el
 625 ;; convert these to use paths-construct-path for eventual migration to init.el
 626 ;; needs to be converted when idiom for constructing "~user" paths is created
 627 ;    (setq user-init-file
 628 ;         (paths-construct-path (list (concat "~" init-file-user)
 629 ;                                     user-init-directory
 630 ;                                     "init.el")))
 631 ;    (unless (file-exists-p (expand-file-name user-init-file))
 632     (setq user-init-file
 633           (paths-construct-path (list (concat "~" init-file-user)
 634                                       (cond
 635                                        ((eq system-type 'ms-dos) "_emacs")
 636                                        (t ".emacs")))))
 637 ;    )
 638     (load user-init-file t t t)
 639 ;; This should not be loaded since custom stuff currently goes into .emacs
 640 ;    (let ((default-custom-file
 641 ;           (paths-construct-path (list (concat "~" init-file-user)
 642 ;                                       user-init-directory
 643 ;                                       "options.el")))
 644 ;      (when (string= custom-file default-custom-file)
 645 ;       (load default-custom-file t t)))
 646     (unless inhibit-default-init
 647       (let ((inhibit-startup-message nil))
 648         ;; Users are supposed to be told their rights.
 649         ;; (Plus how to get help and how to undo.)
 650         ;; Don't you dare turn this off for anyone except yourself.
 651         (load "default" t t)))))
 652
 653 ;;; Load user's init file and default ones.
 654 (defun load-init-file ()
 655   (run-hooks 'before-init-hook)
 656
 657   ;; Run the site-start library if it exists.  The point of this file is
 658   ;; that it is run before .emacs.  There is no point in doing this after
 659   ;; .emacs; that is useless.
 660   (when site-start-file
 661     (load site-start-file t t))
 662
 663   ;; Sites should not disable this.  Only individuals should disable
 664   ;; the startup message.
 665   (setq inhibit-startup-message nil)
 666
 667   (let (debug-on-error-from-init-file
 668         debug-on-error-should-be-set
 669         (debug-on-error-initial
 670          (if (eq init-file-debug t) 'startup init-file-debug)))
 671     (let ((debug-on-error debug-on-error-initial))
 672       (if init-file-debug
 673           ;; Do this without a condition-case if the user wants to debug.
 674           (load-user-init-file init-file-user)
 675         (condition-case error
 676             (progn
 677               (load-user-init-file init-file-user)
 678               (setq init-file-had-error nil))
 679           (error
 680            (message "Error in init file: %s" (error-message-string error))
 681            (display-warning 'initialization
 682              (format "\
 683 An error has occurred while loading %s:
 684
 685 %s
 686
 687 To ensure normal operation, you should investigate the cause of the error
 688 in your initialization file and remove it.  Use the `-debug-init' option
 689 to XEmacs to view a complete error backtrace."
 690                      user-init-file (error-message-string error))
 691              'error)
 692            (setq init-file-had-error t))))
 693       ;; If we can tell that the init file altered debug-on-error,
 694       ;; arrange to preserve the value that it set up.
 695       (or (eq debug-on-error debug-on-error-initial)
 696           (setq debug-on-error-should-be-set t
 697                 debug-on-error-from-init-file debug-on-error)))
 698     (when debug-on-error-should-be-set
 699       (setq debug-on-error debug-on-error-from-init-file)))
 700
 701   (setq init-file-loaded t)
 702
 703   ;; Do this here in case the init file sets mail-host-address.
 704   ;; Don't do this here unless noninteractive, it is frequently wrong. -sb
 705   ;; (or user-mail-address
 706   (when noninteractive
 707     (setq user-mail-address (concat (user-login-name) "@"
 708                                     (or mail-host-address
 709                                         (system-name)))))
 710
 711   (run-hooks 'after-init-hook)
 712   nil)
 713
 714 (defun load-options-file (filename)
 715   "Load the file of saved options (from the Options menu) called FILENAME.
 716 Currently this does nothing but call `load', but it might be redefined
 717 in the future to support automatically converting older options files to
 718 a new format, when variables have changed, etc."
 719   (load filename))
 720
 721 (defun command-line-1 ()
 722   (cond
 723    ((null command-line-args-left)
 724     (unless noninteractive
 725       ;; If there are no switches to process, run the term-setup-hook
 726       ;; before displaying the copyright notice; there may be some need
 727       ;; to do it before doing any output.  If we're not going to
 728       ;; display a copyright notice (because other options are present)
 729       ;; then this is run after those options are processed.
 730       (run-hooks 'term-setup-hook)
 731       ;; Don't let the hook be run twice.
 732       (setq term-setup-hook nil)
 733
 734       ;; Don't clobber a non-scratch buffer if init file
 735       ;; has selected it.
 736       (when (string= (buffer-name) "*scratch*")
 737         (unless (or inhibit-startup-message
 738                     (input-pending-p))
 739           (let ((timeout nil))
 740             (unwind-protect
 741                 ;; Guts of with-timeout
 742                 (catch 'timeout
 743                   (setq timeout (add-timeout startup-message-timeout
 744                                              (lambda (ignore)
 745                                                (condition-case nil
 746                                                    (throw 'timeout t)
 747                                                  (error nil)))
 748                                              nil))
 749                   (startup-splash-frame)
 750                   (or nil;; (pos-visible-in-window-p (point-min))
 751                       (goto-char (point-min)))
 752                   (sit-for 0)
 753                   (setq unread-command-event (next-command-event)))
 754               (when timeout (disable-timeout timeout)))))
 755         (with-current-buffer (get-buffer "*scratch*")
 756           ;; In case the XEmacs server has already selected
 757           ;; another buffer, erase the one our message is in.
 758           (erase-buffer)
 759           (when (stringp initial-scratch-message)
 760             (insert initial-scratch-message))
 761           (set-buffer-modified-p nil)))))
 762
 763    (t
 764     ;; Command-line-options exist
 765     (let ((dir command-line-default-directory)
 766           (file-count 0)
 767           (line nil)
 768           (end-of-options nil)
 769           first-file-buffer file-p arg tem)
 770       (while command-line-args-left
 771         (setq arg (pop command-line-args-left))
 772         (cond
 773          (end-of-options
 774           (setq file-p t))
 775          ((setq tem (when (eq (aref arg 0) ?-)
 776                       (or (assoc arg command-switch-alist)
 777                           (assoc (substring arg 1)
 778                                  command-switch-alist))))
 779           (funcall (cdr tem) arg))
 780          ((string-match "\\`\\+[0-9]+\\'" arg)
 781           (setq line (string-to-int arg)))
 782          ;; "- file" means don't treat "file" as a switch
 783          ;;  ("+0 file" has the same effect; "-" added
 784          ;;   for unixoidiality).
 785          ;; This is worthless; the `unixoid' way is "./file". -jwz
 786          ((or (string= arg "-") (string= arg "--"))
 787           (setq end-of-options t))
 788          (t
 789           (setq file-p t)))
 790
 791         (when file-p
 792           (setq file-p nil)
 793           (incf file-count)
 794           (setq arg (expand-file-name arg dir))
 795           (cond
 796            ((= file-count 1) (setq first-file-buffer
 797                                    (progn (find-file arg) (current-buffer))))
 798            (noninteractive (find-file arg))
 799            (t (find-file-other-window arg)))
 800           (when line
 801             (goto-line line)
 802             (setq line nil))))))))
 803
 804 (defvar startup-presentation-hack-keymap
 805   (let ((map (make-sparse-keymap)))
 806     (set-keymap-name map 'startup-presentation-hack-keymap)
 807     (define-key map '[button1] 'startup-presentation-hack)
 808     (define-key map '[button2] 'startup-presentation-hack)
 809     map)
 810   "Putting yesterday in the future tomorrow.")
 811
 812 (defun startup-presentation-hack ()
 813   (interactive)
 814   (let ((e last-command-event))
 815     (and (button-press-event-p e)
 816          (setq e (extent-at (event-point e)
 817                             (event-buffer e)
 818                             'startup-presentation-hack))
 819          (setq e (extent-property e 'startup-presentation-hack))
 820          (if (consp e)
 821              (apply (car e) (cdr e))
 822            (while (keymapp (indirect-function e))
 823              (let ((map e)
 824                    (overriding-local-map (indirect-function e)))
 825                (setq e (read-key-sequence
 826                         (let ((p (keymap-prompt map t)))
 827                           (cond ((symbolp map)
 828                                  (if p
 829                                      (format "%s %s " map p)
 830                                    (format "%s " map)))
 831                                 (p)
 832                                 (t
 833                                  (prin1-to-string map))))))
 834                (if (and (button-release-event-p (elt e 0))
 835                         (null (key-binding e)))
 836                    (setq e map)         ; try again
 837                  (setq e (key-binding e)))))
 838            (call-interactively e)))))
 839
 840 (defun startup-presentation-hack-help (e)
 841   (setq e (extent-property e 'startup-presentation-hack))
 842   (if (consp e)
 843       (format "Evaluate %S" e)
 844     (symbol-name e)))
 845
 846 (defun splash-frame-present-hack (e v)
 847   ;;  (set-extent-property e 'mouse-face 'highlight)
 848   ;;  (set-extent-property e 'keymap
 849   ;;                       startup-presentation-hack-keymap)
 850   ;;  (set-extent-property e 'startup-presentation-hack v)
 851   ;;  (set-extent-property e 'help-echo
 852   ;;                       'startup-presentation-hack-help))
 853   )
 854
 855 (defun splash-hack-version-string ()
 856   (save-excursion
 857     (save-restriction
 858       (goto-char (point-min))
 859       (re-search-forward "^XEmacs" nil t)
 860       (narrow-to-region (point-at-bol) (point-at-eol))
 861       (goto-char (point-min))
 862       (when (re-search-forward " \\[Lucid\\]" nil t)
 863         (delete-region (match-beginning 0) (match-end 0)))
 864       (when (re-search-forward "[^(][^)]*-[^)]*-" nil t)
 865         (delete-region (1+ (match-beginning 0)) (match-end 0))
 866         (insert "("))
 867       (goto-char (point-max))
 868       (search-backward " " nil t)
 869       (when (search-forward "." nil t)
 870         (delete-region (1- (point)) (point-max))))))
 871
 872 (defun splash-frame-present (l)
 873   (cond ((stringp l)
 874          (insert l))
 875         ((eq (car-safe l) 'face)
 876          ;; (face name string)
 877          (let ((p (point)))
 878            (splash-frame-present (elt l 2))
 879            (if (fboundp 'set-extent-face)
 880                (set-extent-face (make-extent p (point))
 881                                 (elt l 1)))))
 882         ((eq (car-safe l) 'key)
 883          (let* ((c (elt l 1))
 884                 (p (point))
 885                 (k (where-is-internal c nil t)))
 886            (insert (if k (key-description k)
 887                      (format "M-x %s" c)))
 888            (if (fboundp 'set-extent-face)
 889                (let ((e (make-extent p (point))))
 890                  (set-extent-face e 'bold)
 891                  (splash-frame-present-hack e c)))))
 892         ((eq (car-safe l) 'funcall)
 893          ;; (funcall (fun . args) string)
 894          (let ((p (point)))
 895            (splash-frame-present (elt l 2))
 896            (if (fboundp 'set-extent-face)
 897                (splash-frame-present-hack (make-extent p (point))
 898                                           (elt l 1)))))
 899         ((consp l)
 900          (mapcar 'splash-frame-present l))
 901         (t
 902          (error "WTF!?"))))
 903
 904 (defun startup-center-spaces (glyph)
 905   ;; Return the number of spaces to insert in order to center
 906   ;; the given glyph (may be a string or a pixmap).
 907   ;; Assume spaces are as wide as avg-pixwidth.
 908   ;; Won't be quite right for proportional fonts, but it's the best we can do.
 909   ;; Maybe the new redisplay will export something a glyph-width function.
 910   ;;; #### Yes, there is a glyph-width function but it isn't quite what
 911   ;;; #### this was expecting.  Or is it?
 912   ;; (An alternate way to get avg-pixwidth would be to use x-font-properties
 913   ;; and calculate RESOLUTION_X * AVERAGE_WIDTH / 722.7, but it's no better.)
 914
 915   ;; This function is used in about.el too.
 916   (let* ((avg-pixwidth     (round (/ (frame-pixel-width) (frame-width))))
 917          (fill-area-width  (* avg-pixwidth (- fill-column left-margin)))
 918          (glyph-pixwidth   (cond ((stringp glyph)
 919                                   (* avg-pixwidth (length glyph)))
 920                                  ;; #### the pixmap option should be removed
 921                                  ;;((pixmapp glyph)
 922                                  ;; (pixmap-width glyph))
 923                                  ((glyphp glyph)
 924                                   (glyph-width glyph))
 925                                  (t
 926                                   (error "startup-center-spaces: bad arg")))))
 927     (+ left-margin
 928        (round (/ (/ (- fill-area-width glyph-pixwidth) 2) avg-pixwidth)))))
 929
 930 (defun startup-splash-frame-body ()
 931   `("\n" ,(emacs-version) "\n"
 932     ,@(if (string-match "beta" emacs-version)
 933           `( (face (bold blue) ( "This is an Experimental version of XEmacs. "
 934                                  " Type " (key describe-beta)
 935                                  " to see what this means.\n")))
 936         `( "\n"))
 937     (face bold-italic "\
 938 Copyright (C) 1985-1998 Free Software Foundation, Inc.
 939 Copyright (C) 1990-1994 Lucid, Inc.
 940 Copyright (C) 1993-1997 Sun Microsystems, Inc. All Rights Reserved.
 941 Copyright (C) 1994-1996 Board of Trustees, University of Illinois
 942 Copyright (C) 1995-1996 Ben Wing\n\n")
 943
 944     ,@(if (featurep 'sparcworks)
 945           `( "\
 946 Sun provides support for the WorkShop/XEmacs integration package only.
 947 All other XEmacs packages are provided to you \"AS IS\".
 948 For full details, type " (key describe-no-warranty)
 949 " to refer to the GPL Version 2, dated June 1991.\n\n"
 950 ,@(let ((lang (or (getenv "LC_ALL") (getenv "LC_MESSAGES") (getenv "LANG"))))
 951     (if (and
 952          (not (featurep 'mule))         ; Already got mule?
 953          (not (eq 'tty (console-type))) ; No Mule support on tty's yet
 954          lang                           ; Non-English locale?
 955          (not (string= lang "C"))
 956          (not (string-match "^en" lang))
 957          (locate-file "xemacs-mule" exec-path)) ; Comes with Sun WorkShop
 958         '( "\
 959 This version of XEmacs has been built with support for Latin-1 languages only.
 960 To handle other languages you need to run a Multi-lingual (`Mule') version of
 961 XEmacs, by either running the command `xemacs-mule', or by using the X resource
 962 `ESERVE*defaultXEmacsPath: xemacs-mule' when starting XEmacs from Sun WorkShop.\n\n"))))
 963
 964         '("XEmacs comes with ABSOLUTELY NO WARRANTY; type "
 965           (key describe-no-warranty) " for full details.\n"))
 966
 967     "You may give out copies of XEmacs; type "
 968     (key describe-copying) " to see the conditions.\n"
 969     "Type " (key describe-distribution)
 970     " for information on getting the latest version.\n\n"
 971
 972     "Type " (key help-command) " or use the " (face bold "Help") " menu to get help.\n"
 973     "Type " (key advertised-undo) " to undo changes  (`C-' means use the Control key).\n"
 974     "To get out of XEmacs, type " (key save-buffers-kill-emacs) ".\n"
 975     "Type " (key help-with-tutorial) " for a tutorial on using XEmacs.\n"
 976     "Type " (key info) " to enter Info, "
 977     "which you can use to read online documentation.\n"
 978     (face (bold red) ( "\
 979 For tips and answers to frequently asked questions, see the XEmacs FAQ.
 980 \(It's on the Help menu, or type " (key xemacs-local-faq) " [a capital F!].\)"))))
 981
 982 ;; I really hate global variables, oh well.
 983 ;(defvar xemacs-startup-logo-function nil
 984 ;  "If non-nil, function called to provide the startup logo.
 985 ;This function should return an initialized glyph if it is used.")
 986
 987 (defun startup-splash-frame ()
 988   (let ((p (point))
 989 ;       (logo (cond (xemacs-startup-logo-function
 990 ;                    (funcall xemacs-startup-logo-function))
 991 ;                   (t xemacs-logo)))
 992         (logo xemacs-logo)
 993         (cramped-p (eq 'tty (console-type))))
 994     (unless cramped-p (insert "\n"))
 995     (indent-to (startup-center-spaces logo))
 996     (set-extent-begin-glyph (make-extent (point) (point)) logo)
 997     (insert (if cramped-p "\n" "\n\n"))
 998     (splash-frame-present-hack (make-extent p (point)) 'about-xemacs))
 999
1000   (let ((after-change-functions nil))   ; no font-lock, thank you
1001     (dolist (l (startup-splash-frame-body))
1002       (splash-frame-present l)))
1003   (splash-hack-version-string)
1004   (set-buffer-modified-p nil))
1005
1006 ;;  (let ((present-file
1007 ;;         #'(lambda (f)
1008 ;;             (splash-frame-present
1009 ;;            (list 'funcall
1010 ;;                  (list 'find-file-other-window
1011 ;;                        (expand-file-name f data-directory))
1012 ;;                  f)))))
1013 ;;    (insert "For customization examples, see the files ")
1014 ;;    (funcall present-file "sample.emacs")
1015 ;;    (insert " and ")
1016 ;;    (funcall present-file "sample.Xdefaults")
1017 ;;    (insert (format "\nin the directory %s." data-directory)))
1018
1019 (defun startup-set-invocation-environment ()
1020   ;; XEmacs -- Steven Baur says invocation directory is nil if you
1021   ;; try to use XEmacs as a login shell.
1022   (or invocation-directory (setq invocation-directory default-directory))
1023   (setq invocation-directory
1024         ;; don't let /tmp_mnt/... get into the load-path or exec-path.
1025         (abbreviate-file-name invocation-directory)))
1026
1027 (defun startup-setup-paths (roots &optional
1028                                   inhibit-early-packages inhibit-site-lisp
1029                                   debug-paths)
1030   "Setup all the various paths.
1031 ROOTS is a list of plausible roots of the XEmacs directory hierarchy.
1032 If INHIBIT-PACKAGES is non-NIL, don't do packages.
1033 If INHIBIT-SITE-LISP is non-NIL, don't do site-lisp.
1034 If DEBUG-PATHS is non-NIL, print paths as they are detected.
1035 It's idempotent, so call this as often as you like!"
1036
1037   (apply #'(lambda (early late last)
1038              (setq early-packages (and (not inhibit-early-packages)
1039                                        early))
1040              (setq late-packages late)
1041              (setq last-packages last))
1042          (packages-find-packages roots))
1043
1044   (setq early-package-load-path (packages-find-package-load-path early-packages))
1045   (setq late-package-load-path (packages-find-package-load-path late-packages))
1046   (setq last-package-load-path (packages-find-package-load-path last-packages))
1047
1048   (if debug-paths
1049       (progn
1050         (princ (format "configure-package-path:\n%S\n" configure-package-path)
1051                'external-debugging-output)
1052         (princ (format "early-packages and early-package-load-path:\n%S\n%S\n"
1053                        early-packages early-package-load-path)
1054                'external-debugging-output)
1055         (princ (format "late-packages and late-package-load-path:\n%S\n%S\n"
1056                        late-packages late-package-load-path)
1057                'external-debugging-output)
1058         (princ (format "last-packages and last-package-load-path:\n%S\n%S\n"
1059                        last-packages last-package-load-path)
1060                'external-debugging-output)))
1061
1062   (setq lisp-directory (paths-find-lisp-directory roots))
1063
1064   (if debug-paths
1065       (princ (format "lisp-directory:\n%S\n" lisp-directory)
1066              'external-debugging-output))
1067
1068   (setq site-directory (and (null inhibit-site-lisp)
1069                             (paths-find-site-lisp-directory roots)))
1070
1071   (if (and debug-paths (null inhibit-site-lisp))
1072       (princ (format "site-directory:\n%S\n" site-directory)
1073              'external-debugging-output))
1074
1075   (setq load-path (paths-construct-load-path roots
1076                                              early-package-load-path
1077                                              late-package-load-path
1078                                              last-package-load-path
1079                                              lisp-directory
1080                                              site-directory))
1081
1082   (setq Info-directory-list
1083         (paths-construct-info-path roots
1084                                    early-packages late-packages last-packages))
1085
1086
1087   (if debug-paths
1088       (princ (format "Info-directory-list:\n%S\n" Info-directory-list)
1089              'external-debugging-output))
1090
1091   (if (boundp 'lock-directory)
1092       (progn
1093         (setq lock-directory (paths-find-lock-directory roots))
1094         (setq superlock-file (paths-find-superlock-file lock-directory))
1095
1096         (if debug-paths
1097             (progn
1098               (princ (format "lock-directory:\n%S\n" lock-directory)
1099                      'external-debugging-output)
1100               (princ (format "superlock-file:\n%S\n" superlock-file)
1101                      'external-debugging-output)))))
1102
1103   (setq exec-directory (paths-find-exec-directory roots))
1104
1105   (if debug-paths
1106       (princ (format "exec-directory:\n%s\n" exec-directory)
1107              'external-debugging-output))
1108
1109   (setq exec-path
1110         (paths-construct-exec-path roots exec-directory
1111                                    early-packages late-packages last-packages))
1112
1113   (if debug-paths
1114       (princ (format "exec-path:\n%S\n" exec-path)
1115              'external-debugging-output))
1116
1117   (setq doc-directory (paths-find-doc-directory roots))
1118
1119   (if debug-paths
1120       (princ (format "doc-directory:\n%S\n" doc-directory)
1121              'external-debugging-output))
1122
1123   (setq data-directory (paths-find-data-directory roots))
1124
1125   (if debug-paths
1126       (princ (format "data-directory:\n%S\n" data-directory)
1127              'external-debugging-output))
1128
1129   (setq data-directory-list (paths-construct-data-directory-list data-directory
1130                                                                  early-packages
1131                                                                  late-packages
1132                                                                  last-packages))
1133   (if debug-paths
1134       (princ (format "data-directory-list:\n%S\n" data-directory-list)
1135              'external-debugging-output)))
1136
1137 (defun startup-find-roots-warning ()
1138   (save-excursion
1139     (set-buffer (get-buffer-create " *warning-tmp*"))
1140     (erase-buffer)
1141     (buffer-disable-undo (current-buffer))
1142
1143     (insert "Couldn't find an obvious default for the root of the\n"
1144             "XEmacs hierarchy.")
1145
1146     (princ "\nWARNING:\n" 'external-debugging-output)
1147     (princ (buffer-string) 'external-debugging-output)))
1148
1149 (defun startup-setup-paths-warning ()
1150   (let ((lock (if (boundp 'lock-directory) lock-directory 't))
1151         (warnings '()))
1152     (if (and (stringp lock) (null (file-directory-p lock)))
1153         (setq lock nil))
1154     (cond
1155      ((null (and lisp-directory exec-directory data-directory doc-directory
1156                  load-path
1157                  lock))
1158       (save-excursion
1159         (set-buffer (get-buffer-create " *warning-tmp*"))
1160         (erase-buffer)
1161         (buffer-disable-undo (current-buffer))
1162         (if (null lisp-directory) (push "lisp-directory" warnings))
1163         (if (null lock)           (push "lock-directory" warnings))
1164         (if (null exec-directory) (push "exec-directory" warnings))
1165         (if (null data-directory) (push "data-directory" warnings))
1166         (if (null doc-directory)  (push "doc-directory"  warnings))
1167         (if (null load-path)      (push "load-path"      warnings))
1168
1169         (insert "Couldn't find obvious defaults for:\n")
1170         (while warnings
1171           (insert (car warnings) "\n")
1172           (setq warnings (cdr warnings)))
1173         (insert "Perhaps some directories don't exist, "
1174                 "or the XEmacs executable,\n" (concat invocation-directory
1175                                                      invocation-name)
1176                 "\nis in a strange place?")
1177
1178         (princ "\nWARNING:\n" 'external-debugging-output)
1179         (princ (buffer-string) 'external-debugging-output)
1180         (erase-buffer)
1181         t)))))
1182
1183 ;;; startup.el ends here