From 4b2eca745a7256a7c2d2c640f51cd04a34289094 Mon Sep 17 00:00:00 2001 From: Juan Jose Garcia Ripoll Date: Sat, 10 Dec 2011 20:12:14 +0100 Subject: [PATCH] Replace more uses of DEFVAR with DEFPARAMETER --- src/clos/combin.lsp | 2 +- src/clos/conditions.lsp | 6 ++-- src/clos/method.lsp | 6 ++-- src/cmp/cmpmain.lsp | 2 ++ src/lsp/describe.lsp | 10 +++---- src/lsp/ffi.lsp | 10 +++---- src/lsp/format.lsp | 20 ++++++------- src/lsp/helpfile.lsp | 2 +- src/lsp/iolib.lsp | 2 +- src/lsp/loop.lsp | 4 +-- src/lsp/loop2.lsp | 16 +++++------ src/lsp/module.lsp | 6 ++-- src/lsp/top.lsp | 64 ++++++++++++++++++++--------------------- src/lsp/trace.lsp | 18 ++++++------ 14 files changed, 85 insertions(+), 83 deletions(-) diff --git a/src/clos/combin.lsp b/src/clos/combin.lsp index abcb60ace..eea4ff5aa 100644 --- a/src/clos/combin.lsp +++ b/src/clos/combin.lsp @@ -190,7 +190,7 @@ ;; and it outputs an anonymous function which is the effective method. ;; -(defvar *method-combinations* '()) +(defparameter *method-combinations* '()) (defun install-method-combination (name function) (setf (getf *method-combinations* name) function) diff --git a/src/clos/conditions.lsp b/src/clos/conditions.lsp index 9e775084c..45e7b97e1 100644 --- a/src/clos/conditions.lsp +++ b/src/clos/conditions.lsp @@ -35,8 +35,8 @@ ;;; Restarts -(defvar *restart-clusters* ()) -(defvar *condition-restarts* ()) +(defparameter *restart-clusters* ()) +(defparameter *condition-restarts* ()) ;;; do we need copy-list if *restart-clusters* has only one element? Beppe (defun compute-restarts (&optional condition) @@ -366,7 +366,7 @@ |# -(defvar *handler-clusters* nil) +(defparameter *handler-clusters* nil) (defmacro handler-bind (bindings &body forms) (unless (every #'(lambda (x) (and (listp x) (= (length x) 2))) bindings) diff --git a/src/clos/method.lsp b/src/clos/method.lsp index 85164aa9f..cccf92e47 100644 --- a/src/clos/method.lsp +++ b/src/clos/method.lsp @@ -13,18 +13,18 @@ ;;; ---------------------------------------------------------------------- -(defvar *method-size* 32) ; Size of methods hash tables +(defparameter *method-size* 32) ; Size of methods hash tables ;;; This holds fake methods created during bootstrap. ;;; It is an alist of: ;;; (method-name {method}+) -(defvar *early-methods* nil) +(defparameter *early-methods* nil) ;;; ;;; This is used by combined methods to communicate the next methods to ;;; the methods they call. ;;; -(defvar *next-methods* nil) +(defparameter *next-methods* nil) ;;; ---------------------------------------------------------------------- diff --git a/src/cmp/cmpmain.lsp b/src/cmp/cmpmain.lsp index 9df93aef1..b78090d51 100755 --- a/src/cmp/cmpmain.lsp +++ b/src/cmp/cmpmain.lsp @@ -167,6 +167,8 @@ the environment variable TMPDIR to a different value." template)) (defun static-lib-ar (lib object-files) (let ((lib (brief-namestring lib))) + (when (probe-file lib) + (delete-file lib)) (safe-run-program *ar* (list* "cr" lib (mapcar #'brief-namestring object-files))) (safe-run-program *ranlib* (list lib)))) diff --git a/src/lsp/describe.lsp b/src/lsp/describe.lsp index df250b0cb..790a6779d 100644 --- a/src/lsp/describe.lsp +++ b/src/lsp/describe.lsp @@ -13,12 +13,12 @@ (in-package "SYSTEM") -(defvar *inspect-level* 0) -(defvar *inspect-history* nil) -(defvar *inspect-mode* nil) +(defparameter *inspect-level* 0) +(defparameter *inspect-history* nil) +(defparameter *inspect-mode* nil) -(defvar *old-print-level* nil) -(defvar *old-print-length* nil) +(defparameter *old-print-level* nil) +(defparameter *old-print-length* nil) ;; Either the inspector reads and writes everything on *standard-output*, diff --git a/src/lsp/ffi.lsp b/src/lsp/ffi.lsp index c4a414fe1..9f90c664c 100644 --- a/src/lsp/ffi.lsp +++ b/src/lsp/ffi.lsp @@ -55,9 +55,9 @@ ;;; FOREIGN TYPES ;;; -(defvar *ffi-types* (make-hash-table :size 128)) +(defparameter *ffi-types* (make-hash-table :size 128)) -(defvar *use-dffi* t) +(defparameter *use-dffi* t) (defmacro def-foreign-type (name definition) `(eval-when (:compile-toplevel :load-toplevel :execute) @@ -310,7 +310,7 @@ ;;; POINTERS ;;; -(defvar +null-cstring-pointer+ (si:allocate-foreign-data :pointer-void 0)) +(defparameter +null-cstring-pointer+ (si:allocate-foreign-data :pointer-void 0)) (defun pointer-address (ptr) (si::foreign-data-address ptr)) @@ -582,7 +582,7 @@ (define-symbol-macro ,lisp-name (ffi:deref-pointer (get-sysprop ',lisp-name 'ffi-foreign-var) ',type) ))) - `(defvar ,lisp-name ,inline-form)) + `(defparameter ,lisp-name ,inline-form)) ))) (defun find-foreign-library (names directories &key drive-letters types) @@ -619,7 +619,7 @@ ))))) nil) -(defvar +loaded-libraries+ nil) +(defparameter +loaded-libraries+ nil) (defun do-load-foreign-library (tmp &optional system-library) (let* ((path (cond ((pathnamep tmp) tmp) diff --git a/src/lsp/format.lsp b/src/lsp/format.lsp index 3f4fbb715..565318da9 100644 --- a/src/lsp/format.lsp +++ b/src/lsp/format.lsp @@ -90,7 +90,7 @@ ;;; DO NOT EVEN THINK OF ATTEMPTING TO UNDERSTAND THIS CODE WITHOUT READING ;;; THE PAPER! -(defvar *digits* "0123456789") +(defparameter *digits* "0123456789") (defun flonum-to-string (x &optional width fdigits scale fmin) (declare (type float x)) @@ -225,18 +225,18 @@ :end (format-directive-end struct)))) #+formatter -(defvar *format-directive-expanders* +(defparameter *format-directive-expanders* (make-array char-code-limit :initial-element nil)) -(defvar *format-directive-interpreters* +(defparameter *format-directive-interpreters* (make-array char-code-limit :initial-element nil)) -(defvar *default-format-error-control-string* nil) -(defvar *default-format-error-offset* nil) +(defparameter *default-format-error-control-string* nil) +(defparameter *default-format-error-offset* nil) ;; If this flag is 1, directives ~W, ~_, ~<...~:>, ~I or ~T were found. ;; If the flag is 2, directive ~<...~:;...~> was found. ;; NIL otherwise. -(defvar *output-layout-mode* nil) +(defparameter *output-layout-mode* nil) ;; The condition FORMAT-ERROR is found later in conditions.lsp @@ -358,14 +358,14 @@ ;;; Used both by the expansion stuff and the interpreter stuff. When it is ;;; non-NIL, up-up-and-out (~:^) is allowed. Otherwise, ~:^ isn't allowed. ;;; -(defvar *up-up-and-out-allowed* nil) +(defparameter *up-up-and-out-allowed* nil) ;;; *LOGICAL-BLOCK-POPPER* -- internal. ;;; ;;; Used by the interpreter stuff. When it non-NIL, its a function that will ;;; invoke PPRINT-POP in the right lexical environemnt. ;;; -(defvar *logical-block-popper* nil) +(defparameter *logical-block-popper* nil) ;;; *EXPANDER-NEXT-ARG-MACRO* -- internal. ;;; @@ -373,7 +373,7 @@ ;;; can change it. ;;; #+formatter -(defvar *expander-next-arg-macro* 'expander-next-arg) +(defparameter *expander-next-arg-macro* 'expander-next-arg) ;;; *ONLY-SIMPLE-ARGS* -- internal. ;;; @@ -390,7 +390,7 @@ ;;; again with it bound to T. If this is T, we don't try to do anything ;;; fancy with args. ;;; -(defvar *orig-args-available* nil) +(defparameter *orig-args-available* nil) ;;; *SIMPLE-ARGS* -- internal. ;;; diff --git a/src/lsp/helpfile.lsp b/src/lsp/helpfile.lsp index b3c8b57a9..092c84791 100644 --- a/src/lsp/helpfile.lsp +++ b/src/lsp/helpfile.lsp @@ -104,7 +104,7 @@ (progn (setq *documentation-pool* (list (make-hash-table :test #'equal :size 128) "SYS:help.doc")) - (defvar *keep-documentation* t)) + (defparameter *keep-documentation* t)) (defun new-documentation-pool (&optional (size 1024)) "Args: (&optional hash-size) diff --git a/src/lsp/iolib.lsp b/src/lsp/iolib.lsp index 1e4f6748a..abadef87e 100644 --- a/src/lsp/iolib.lsp +++ b/src/lsp/iolib.lsp @@ -196,7 +196,7 @@ printed. If FORMAT-STRING is NIL, however, no prompt will appear." (set-dispatch-macro-character #\# #\s 'sharp-s-reader) (set-dispatch-macro-character #\# #\S 'sharp-s-reader) -(defvar *dribble-closure* nil) +(defparameter *dribble-closure* nil) (defun dribble (&optional (pathname "DRIBBLE.LOG" psp)) "Args: (&optional filespec) diff --git a/src/lsp/loop.lsp b/src/lsp/loop.lsp index 9662dfbd4..cbc508b2e 100644 --- a/src/lsp/loop.lsp +++ b/src/lsp/loop.lsp @@ -565,7 +565,7 @@ The offending clause" (declare (ignore data-type)) substitutable-expression) -(defvar loop-floating-point-types +(defparameter loop-floating-point-types '(flonum float short-float single-float double-float long-float)) (defun loop-typed-init (data-type) @@ -914,7 +914,7 @@ The offending clause" (declare (fixnum ans)) (and (< ans 20.) ans))))) -(defvar loop-simplep +(defparameter loop-simplep '(> < <= >= /= + - 1+ 1- ash equal atom setq prog1 prog2 and or = aref char schar sbit svref)) (defun loop-simplep-1 (x) diff --git a/src/lsp/loop2.lsp b/src/lsp/loop2.lsp index 8ae6a419c..b46e01349 100755 --- a/src/lsp/loop2.lsp +++ b/src/lsp/loop2.lsp @@ -145,7 +145,7 @@ #-Genera `(copy-list ,l) ) -(defvar *loop-real-data-type* 'real) +(defparameter *loop-real-data-type* 'real) (defun loop-optimization-quantities (env) (declare (si::c-local)) @@ -321,7 +321,7 @@ constructed. infinity-data) -(defvar *loop-minimax-type-infinities-alist* +(defparameter *loop-minimax-type-infinities-alist* ;; This is the sort of value this should take on for a Lisp that has ;; "eminently usable" infinities. n.b. there are neither constants nor ;; printed representations for infinities defined by CL. @@ -528,7 +528,7 @@ code to be loaded. ;;;; Setq Hackery -(defvar *loop-destructuring-hooks* +(defparameter *loop-destructuring-hooks* nil "If not NIL, this must be a list of two things: a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring.") @@ -554,7 +554,7 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring. var-val-pairs))) -(defvar *loop-desetq-temporary* +(defparameter *loop-desetq-temporary* (make-symbol "LOOP-DESETQ-TEMP")) @@ -764,11 +764,11 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring. ;;;; LOOP Iteration Optimization -(defvar *loop-duplicate-code* +(defparameter *loop-duplicate-code* nil) -(defvar *loop-iteration-flag-variable* +(defparameter *loop-iteration-flag-variable* (make-symbol "LOOP-NOT-FIRST-TIME")) @@ -868,7 +868,7 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring. ans))) -(defvar *special-code-sizes* +(defparameter *special-code-sizes* '((return 0) (progn 0) (null 1) (not 1) (eq 1) (car 1) (cdr 1) (when 1) (unless 1) (if 1) @@ -880,7 +880,7 @@ a LET-like macro, and a SETQ-like macro, which perform LOOP-style destructuring. (cddaar 4) (cddadr 4) (cdddar 4) (cddddr 4))) -(defvar *estimate-code-size-punt* +(defparameter *estimate-code-size-punt* '(block do do* dolist flet diff --git a/src/lsp/module.lsp b/src/lsp/module.lsp index f84dc082a..45e45e6f5 100644 --- a/src/lsp/module.lsp +++ b/src/lsp/module.lsp @@ -19,11 +19,11 @@ ;;;; exported specials -(defvar *modules* () +(defparameter *modules* () "This is a list of module names that have been loaded into Lisp so far. It is used by PROVIDE and REQUIRE.") -(defvar *module-provider-functions* nil +(defparameter *module-provider-functions* nil "See function documentation for REQUIRE") ;;;; PROVIDE and REQUIRE @@ -34,7 +34,7 @@ Module-name is a string designator" (pushnew (string module-name) *modules* :test #'string=) t) -(defvar *requiring* nil) +(defparameter *requiring* nil) (defun require-error (control &rest arguments) (error "Module error: ~?" control arguments)) diff --git a/src/lsp/top.lsp b/src/lsp/top.lsp index 70974b24a..d674ef7bb 100644 --- a/src/lsp/top.lsp +++ b/src/lsp/top.lsp @@ -24,29 +24,29 @@ (export '(*break-readtable* *break-on-warnings* *tpl-evalhook* *tpl-prompt-hook*)) -(defvar *quit-tag* (cons nil nil)) -(defvar *quit-tags* nil) -(defvar *break-level* 0) ; nesting level of error loops -(defvar *break-env* nil) -(defvar *ihs-base* 0) -(defvar *ihs-top* (ihs-top)) -(defvar *ihs-current* 0) -(defvar *frs-base* 0) -(defvar *frs-top* 0) -(defvar *tpl-continuable* t) -(defvar *tpl-prompt-hook* nil) -(defvar *eof* (cons nil nil)) +(defparameter *quit-tag* (cons nil nil)) +(defparameter *quit-tags* nil) +(defparameter *break-level* 0) ; nesting level of error loops +(defparameter *break-env* nil) +(defparameter *ihs-base* 0) +(defparameter *ihs-top* (ihs-top)) +(defparameter *ihs-current* 0) +(defparameter *frs-base* 0) +(defparameter *frs-top* 0) +(defparameter *tpl-continuable* t) +(defparameter *tpl-prompt-hook* nil) +(defparameter *eof* (cons nil nil)) -(defvar *last-error* nil) +(defparameter *last-error* nil) -(defvar *break-message* nil) +(defparameter *break-message* nil) -(defvar *break-readtable* nil) -(defvar *tpl-level* -1) ; nesting level of top-level loops -(defvar *step-level* 0) ; repeated from trace.lsp +(defparameter *break-readtable* nil) +(defparameter *tpl-level* -1) ; nesting level of top-level loops +(defparameter *step-level* 0) ; repeated from trace.lsp -(defvar *break-hidden-functions* '(error cerror apply funcall invoke-debugger)) -(defvar *break-hidden-packages* (list #-ecl-min (find-package 'system))) +(defparameter *break-hidden-functions* '(error cerror apply funcall invoke-debugger)) +(defparameter *break-hidden-packages* (list #-ecl-min (find-package 'system))) (defconstant tpl-commands '(("Top level commands" @@ -159,7 +159,7 @@ :exit &eval &optional status [Top level Command]~%") ))) -(defvar *tpl-commands* tpl-commands) +(defparameter *tpl-commands* tpl-commands) (defconstant break-commands '("Break commands" @@ -381,7 +381,7 @@ See also: :variables.~%") )) -(defvar *lisp-initialized* nil) +(defparameter *lisp-initialized* nil) (defun top-level (&optional (process-command-line nil)) "Args: () @@ -413,11 +413,11 @@ under certain conditions; see file 'Copyright' for details.") #+threads (progn -(defvar *console-lock* (mp:make-lock :name "Console lock")) +(defparameter *console-lock* (mp:make-lock :name "Console lock")) #-:win32 -(defvar *console-available* (mp:make-condition-variable)) -(defvar *console-owner* nil) -(defvar *console-waiting-list* '()) +(defparameter *console-available* (mp:make-condition-variable)) +(defparameter *console-owner* nil) +(defparameter *console-waiting-list* '()) (defun candidate-to-get-console-p (process) (or (null *console-owner*) @@ -465,8 +465,8 @@ under certain conditions; see file 'Copyright' for details.") (delete-from-waiting-list mp:*current-process*) (release-console mp:*current-process*))) -(defvar *allow-recursive-debug* nil) -(defvar *debug-status* nil) +(defparameter *allow-recursive-debug* nil) +(defparameter *debug-status* nil) (defun simple-terminal-interrupt () (error 'ext:interactive-interrupt)) @@ -496,7 +496,7 @@ Use special code 0 to cancel this operation.") (t (format t "~&Not a valid process number"))))) -(defvar *interrupt-lonely-threads-p* t) +(defparameter *interrupt-lonely-threads-p* t) (defun single-threaded-terminal-interrupt () (restart-case (simple-terminal-interrupt) @@ -656,7 +656,7 @@ Use special code 0 to cancel this operation.") (t (return (read)))))) -(defvar *debug-tpl-commands* nil) +(defparameter *debug-tpl-commands* nil) (defun harden-command (cmd-form) `(block @@ -1268,7 +1268,7 @@ Use special code 0 to cancel this operation.") (defun tpl-untrace-command (&rest functions) (untrace* functions)) -(defvar *tpl-last-load* nil) +(defparameter *tpl-last-load* nil) (defun tpl-load-command (&rest files) (when files @@ -1276,7 +1276,7 @@ Use special code 0 to cancel this operation.") (dolist (file *tpl-last-load*) (load file)) *tpl-last-load*) -(defvar *tpl-last-compile* nil) +(defparameter *tpl-last-compile* nil) (defun tpl-compile-command (&rest files) (when files @@ -1368,7 +1368,7 @@ package." commands) (nconc commands (list restart-commands)))) -(defvar *default-debugger-maximum-depth* 16) +(defparameter *default-debugger-maximum-depth* 16) (defun check-default-debugger-runaway () (when (< *default-debugger-maximum-depth* *break-level*) diff --git a/src/lsp/trace.lsp b/src/lsp/trace.lsp index 6055cf606..9ae42a6bc 100644 --- a/src/lsp/trace.lsp +++ b/src/lsp/trace.lsp @@ -12,9 +12,9 @@ (in-package "SYSTEM") -(defvar *trace-level* 0) -;; (defvar *trace-list* nil) ; In all_symbols.d ! -(defvar *trace-max-indent* 20) +(defparameter *trace-level* 0) +;; (defparameter *trace-list* nil) ; In all_symbols.d ! +(defparameter *trace-max-indent* 20) (defmacro trace (&rest r) "Syntax: (trace ({function-name | ({function-name}+)} {keyword [form]\}*) @@ -59,7 +59,7 @@ all functions." (defun untrace* (r) (mapc #'untrace-one (or r (trace* nil)))) -(defvar *inside-trace* nil) +(defparameter *inside-trace* nil) (defun trace-one (spec) (let* (break exitbreak (entrycond t) (exitcond t) entry exit @@ -221,11 +221,11 @@ all functions." (delete-from-trace-list fname) (values))) -(defvar *step-level* 0) -(defvar *step-action* nil) -(defvar *step-form* nil) -(defvar *step-tag* (cons nil nil)) -(defvar *step-functions* nil) +(defparameter *step-level* 0) +(defparameter *step-action* nil) +(defparameter *step-form* nil) +(defparameter *step-tag* (cons nil nil)) +(defparameter *step-functions* nil) (defconstant step-commands `("Stepper commands" ((:newline) (step-next) :constant