;; Copyright (c) Harlequin Limited, 1987 -- 1994.

;; This is the sample user configuration file for LispWorks.  These settings
;; are already in effect in the system as delivered.  You should review them
;; and see if you want to change any of them: if you do, copy the code into
;; your personal configuration file ~/.lispworks.  For more info, see
;; chapter "Installation and Configuration" in the manual.

(in-package "CL-USER")


;; First, you will want to load any patches to LW you've installed:

(load-all-patches)


;; This variable determines how much information is printed out during
;; compilation.  A value of 1 gives one line per compiled form.
;; Note that the messages produced by compile-file are now controlled
;; by the standard Common Lisp variable *COMPILE-PRINT*.

(setf compiler::*messages* 1)


;; Turn all source debugging features on.

(lw:toggle-source-debugging t)

;; This has the effect of setting the following variables:
#|
(setf compiler::*produce-xref-info* t
      ;; Controls whether the compiler should produce cross-referencing
      ;; information
      compiler::*load-xref-info* t
      ;; Controls whether the cross-referencing information is
      ;; loaded when a fasl file is loaded
      compiler::*notice-changed-definitions* t
      ;; Controls whether the cross-referencer notices when a definition is
      ;; redefined interpretively
      compiler::*generate-source-recording* t
      ;; Controls whether the compiler should generate source file recording
      ;; information
      compiler::*source-file-recording* t
      ;; Controls whether source file recording information produced by the
      ;; compiler is loaded with the fasl file; it also controls whether
      ;; source file information is recorded when a text file is loaded
      compiler::*source-level-debugging* t
      ;; Controls whether the compiler generates source-level debugging information
      )
|#


;; Packages on the list *HIDDEN-PACKAGES* will be excluded from backtraces.
;; You might want to add some of your own.

(pushnew (find-package "SYSTEM") dbg:*hidden-packages*)
(pushnew (find-package "COMPILER") dbg:*hidden-packages*)


;; The following variable determines the maximum number of editor windows
;; which will ordinarily be permitted on the screen at any one time.

(setf editor:*maximum-ordinary-windows* 3)


;; The following three variables control the handling of IN-PACKAGE, which was
;; previously a function but is now a macro.  (See Steele, 2nd edition,
;; pp. 263-4.)  They give the user a choice between correct Common Lisp and
;; backward compatibility.

;; *HANDLE-OLD-IN-PACKAGE* is referenced if an old-style IN-PACKAGE is
;; encountered during the loading of a compiled file.  It should take one of
;; three values:
;;    :QUIET  - quietly ignore it, use the old definition
;;    :WARN   - signal a warning and use the old definition
;;    :ERROR  - signal an error

(setf lw:*handle-old-in-package* :warn)

;; *CONVERT-IN-PACKAGE-TO-MACRO* is referenced by the interpreter and
;; compiler, when a call is encountered which appears to take the form of a
;; function call (either the package name is quoted or there is a :use
;; keyword). It takes the same values, interpreted as follows:
;;    :QUIET  - quietly ignore it, run the old function
;;    :WARN   - signal a warning and run the old function
;;    :ERROR  - signal an error

(setf lw:*convert-in-package-to-macro* :warn)

;; In the event that a call to IN-PACKAGE appears to be creating a new
;; package, the variable *HANDLE-OLD-IN-PACKAGE-USED-AS-MAKE-PACKAGE*
;; is referenced and interpreted as follows:
;;    :QUIET  - handle according to LW:*HANDLE-OLD-IN-PACKAGE*
;;    :WARN   - signal a warning and create the package
;;    :ERROR  - signal a continuable error

(setf lw:*handle-old-in-package-used-as-make-package* :quiet)


;; To retain some compatability with previous versions of LispWorks, the old
;; packages named USER and LISP have been retained as nicknames for the new
;; packages COMMON-LISP-USER and COMMON-LISP respectively.  Note therefore that
;; symbols "in" the USER and LISP packages do not reflect the "old" Common
;; Lisp (as described in Steele edition one) -- see Steele (edition two) page
;; 258.  If you wish to remove these two nicknames, you will need to uncomment
;; the following two lines:
#|
(rename-package "COMMON-LISP-USER" "COMMON-LISP-USER" '("CL-USER"))
(rename-package "COMMON-LISP" "COMMON-LISP" '("CL"))
|#


;; The variable *LOAD-FASL-OR-LISP-FILE* determines whether (LOAD "foo")
;; should load foo.xfasl or foo.lisp, when both exist.  It may take the
;; following values:
;;   :LOAD-NEWER         If the fasl is out-of-date, the lisp file is loaded,
;;                       and a warning message is output in verbose mode.
;;   :LOAD-NEWER-NO-WARN Like :LOAD-NEWER, but without the warning.
;;   :LOAD-FASL          Always choose fasl files in preference to
;;                       lisp files, but when verbose, warn if the
;;                       lisp file is newer.
;;   :LOAD-FASL-NO-WARN  Like :LOAD-FASL, but without the warning.
;;   :LOAD-LISP          Always choose lisp files in preference to fasl.
;;   :RECOMPILE          If the fasl file is out-of-date or there is none,
;;                       compile and load the new fasl.

(setf lw:*load-fasl-or-lisp-file* :load-fasl)


;; When *WARN-ON-UNBOUND-BEFORE-SETQ* is non-NIL, a warning is signalled if the
;; interpreter sets an unbound symbol.

(setf lw:*warn-on-unbound-before-setq* nil)


;; LispWorks can signal a warning or an error for redefinition of a system
;; function, i.e., any function whose name is external to any of the packages
;; in this list.

(setf lw:*packages-for-warn-on-redefinition*
      '("COMMON-LISP" "KEYWORD"
        "LISPWORKS"
        "CLOS" "COMPILER" "SYSTEM" "DBG" "DEFSYSTEM" "FFI" "CONDITIONS"
        "GP" "COLOR"
        "XLIB" "CLUE" "TOOLKIT"
        "EDITOR" "TOOLS" "BOOK" "CLASSWORKS"
        ))

;; This variable controls what to do if a system function (see above) is redefined.
;;    :WARN for a warning
;;    :ERROR for an error

(setf lw:*handle-warn-on-redefinition* :error)


;; This variable controls what happens at load time if a fasl file references
;; a symbol in a package which does not exist.  There are three possibilities:
;;	:ERROR	Signals an error.  This is the standard behaviour.  Continuing
;;              from the error creates the package.
;;	:WARN	Signals a warning and creates the package.
;;	:CREATE	Silently creates the package.

(setf lw:*unknown-package-during-fasl-load* :error)


;; This variable specifies the shell used by M-x Shell Command and the shell
;; windows.  A default was probably provided when LispWorks was configured for
;; your site (see #P"user-lib:config;configure.lisp"), but you will have your
;; own preference.  The value should be a string containing the filename of a
;; shell (e.g., "/bin/sh").

(setf editor::*shell-shell*
      ;; This code looks at the environment variable ESHELL; or if there
      ;; is none, SHELL; if there is no SHELL, it uses the site default.
      (or (getenv "ESHELL") (getenv "SHELL") editor::*shell-shell*))


;; If this variable is set to true then buffers will be displayed with the
;; required definition on the top line rather than in the centre of the
;; window.

(setf editor:*tags-definition-top-window* nil)


;; The variable *REUSE-INSPECTORS* determines whether inspector windows should
;; be re-used or created afresh.

(setf lw:*reuse-inspectors* nil)


;; The variable *REUSE-DEBUGGERS* determines whether debugger windows (created
;; by the "Debug" menu item in listeners, or the "Debug" option in notifiers)
;; should be re-used or created afresh.  It may take the following values:
;;   NIL        Do not reuse.
;;   T          Reuse, sending window to back when not in use.
;;   :ICONIFY   Reuse, withdrawing window from screen when not in use.

#-lispworks-delivery (setf lw:*reuse-debuggers* nil)


;; The variable *REUSE-MAILERS* determines whether mailer windows (for
;; composing mail) should be re-used or created afresh.  It may take the
;; following values:
;;   NIL        Do not reuse.
;;   T          Reuse, sending window to back when not in use.
;;   :ICONIFY   Reuse, withdrawing window from screen when not in use.

(setf lw:*reuse-mailers* :iconify)


;; This variable determines whether errors should enter directly into the
;; debugger without flagging the condition in a notifier first.

#-lispworks-delivery (setf lw:*enter-debugger-directly* nil)


;; This flag is used by READ to tell when it's OK to treat right parentheses
;; as whitespace.  It may take the following values:
;;   NIL     Not OK, flag an error.  This is the standard value.
;;   T       OK, ignore the parenthesis.
;;   :WARN   Signal a warning and proceed.

(setf sys::*right-paren-whitespace* nil)


;; This function, if called with the argument T, allows the compiler to
;; optimize CLOS slot access by assuming that the slot will never change its
;; allocation, either by class redefinition or by a subclass.  Code compiled
;; with this assumption will go wrong if a slot does change its allocation.

(clos::slot-fixed-allocation nil)


;; Set this variable to specify the default font used by LispWorks.  This font
;; MUST be installed in the X server for the LispWorks environment to run.
;; All other fonts used by LispWorks are specified via the resources.lisp
;; file.  Any specified therein which are not installed in the X server will
;; be defaulted.  Your site configuration should already have set a safe value
;; for this variable, but you might prefer another font.

(setf gp::*clx-system-font* (gp:gf "adobe" "courier" :medium :roman 12))


;; Also see your site configuration file, #P"user-lib:config;configure.lisp",
;; for other configuration options you might want to change according to your
;; personal preferences, or the configuration of your machine.

;;;----------------------------------------
;;; Personal configuration


;;;----------------------------------------