From 29a9ccc860532b32c566aec095f570e999a9c52c Mon Sep 17 00:00:00 2001 From: William Harold Newman Date: Mon, 14 Jan 2002 02:11:59 +0000 Subject: [PATCH] 0.pre7.129: s/function/fun in... ...valid-function ...seen-function ...arg-function ...cached-function ...setf-function ...escape-function ...cleanup-function ...propagate-function ...really-function ...free-function ...apparent-function ...extract-function ...function-continuation ...function-info ...continuation-function ...coerce-function ...first-function ...core-function ...initial-function ...function-entry ...function-subtype ...compute-function ...function-epilogue ...function-prologue s/set-up-function-translation/!set-up-fun-translation/ --- package-data-list.lisp-expr | 8 +-- src/code/debug-info.lisp | 2 +- src/code/early-setf.lisp | 4 +- src/code/fop.lisp | 2 +- src/code/kernel.lisp | 8 +-- src/code/ntrace.lisp | 2 +- src/code/print.lisp | 2 +- src/code/save.lisp | 2 +- src/code/seq.lisp | 12 ++--- src/compiler/aliencomp.lisp | 4 +- src/compiler/alpha/call.lisp | 12 ++--- src/compiler/alpha/parms.lisp | 4 +- src/compiler/alpha/system.lisp | 10 ++-- src/compiler/checkgen.lisp | 14 +++--- src/compiler/ctype.lisp | 12 ++--- src/compiler/debug.lisp | 26 +++++----- src/compiler/disassem.lisp | 44 ++++++++--------- src/compiler/dump.lisp | 2 +- src/compiler/early-c.lisp | 6 +-- src/compiler/float-tran.lisp | 2 +- src/compiler/generic/core.lisp | 6 +-- src/compiler/generic/genesis.lisp | 14 +++--- src/compiler/generic/target-core.lisp | 21 ++++---- src/compiler/generic/vm-fndb.lisp | 4 +- src/compiler/generic/vm-macs.lisp | 12 ++--- src/compiler/globaldb.lisp | 7 ++- src/compiler/info-functions.lisp | 8 +-- src/compiler/ir1-translators.lisp | 20 ++++---- src/compiler/ir1final.lisp | 22 ++++----- src/compiler/ir1opt.lisp | 87 ++++++++++++++++----------------- src/compiler/ir1tran.lisp | 69 +++++++++++++------------- src/compiler/ir1util.lisp | 4 +- src/compiler/ir2tran.lisp | 14 +++--- src/compiler/knownfun.lisp | 32 ++++++------ src/compiler/locall.lisp | 2 +- src/compiler/ltn.lisp | 38 +++++++------- src/compiler/macros.lisp | 6 +-- src/compiler/main.lisp | 12 ++--- src/compiler/meta-vmdef.lisp | 15 +++--- src/compiler/node.lisp | 4 +- src/compiler/saptran.lisp | 4 +- src/compiler/seqtran.lisp | 17 ++++--- src/compiler/target-disassem.lisp | 3 ++ src/compiler/x86/call.lisp | 17 ++++--- src/compiler/x86/memory.lisp | 4 +- src/compiler/x86/parms.lisp | 4 +- src/compiler/x86/system.lisp | 10 ++-- src/pcl/boot.lisp | 2 +- src/pcl/combin.lisp | 4 +- src/pcl/dfun.lisp | 14 +++--- src/pcl/methods.lisp | 2 +- version.lisp-expr | 2 +- 52 files changed, 331 insertions(+), 327 deletions(-) diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr index 5dda672..dd272f8 100644 --- a/package-data-list.lisp-expr +++ b/package-data-list.lisp-expr @@ -180,7 +180,7 @@ "*BACKEND-T-PRIMITIVE-TYPE*" "*CODE-SEGMENT*" - "*COUNT-VOP-USAGES*" "*ELSEWHERE*" "*FREE-FUNCTIONS*" + "*COUNT-VOP-USAGES*" "*ELSEWHERE*" "*FREE-FUNS*" "*SETF-ASSUMED-FBOUNDP*" "*SUPPRESS-VALUES-DECLARATION*" @@ -200,7 +200,7 @@ "COMPILE-LAMBDA-FOR-DEFUN" "%COMPILER-DEFUN" "COMPILER-ERROR" "COMPONENT" "COMPONENT-HEADER-LENGTH" - "COMPONENT-INFO" "COMPONENT-LIVE-TN" "COMPUTE-FUNCTION" + "COMPONENT-INFO" "COMPONENT-LIVE-TN" "COMPUTE-FUN" "COMPUTE-OLD-NFP" "COPY-MORE-ARG" "CURRENT-BINDING-POINTER" "CURRENT-NFP-TN" "CURRENT-STACK-POINTER" "DEALLOC-ALIEN-STACK-SPACE" @@ -1211,7 +1211,7 @@ is a good idea, but see SB-SYS re. blurring of boundaries." "FDEFN-NAME" "FDEFN-FUN" "FDEFN-MAKUNBOUND" "OUTER-FDEFN" "%COERCE-CALLABLE-TO-FUN" - "FUNCTION-SUBTYPE" "*MAXIMUM-ERROR-DEPTH*" + "FUN-SUBTYPE" "*MAXIMUM-ERROR-DEPTH*" "%SET-SYMBOL-PLIST" "INFINITE-ERROR-PROTECT" "FIND-CALLER-NAME-AND-FRAME" "%SET-SYMBOL-VALUE" "%SET-SYMBOL-PACKAGE" @@ -1831,7 +1831,7 @@ structure representations" "*TARGET-MOST-POSITIVE-FIXNUM*" "STATIC-SPACE-START" "STATIC-SPACE-END" "TRACE-TABLE-CALL-SITE" - "TRACE-TABLE-FUNCTION-EPILOGUE" "TRACE-TABLE-FUNCTION-PROLOGUE" + "TRACE-TABLE-FUN-EPILOGUE" "TRACE-TABLE-FUN-PROLOGUE" "TRACE-TABLE-NORMAL" "N-WIDETAG-BITS" "WIDETAG-MASK" "UNBOUND-MARKER-WIDETAG" "UNSIGNED-IMMEDIATE-SC-NUMBER" diff --git a/src/code/debug-info.lisp b/src/code/debug-info.lisp index ecc94cf..760e594 100644 --- a/src/code/debug-info.lisp +++ b/src/code/debug-info.lisp @@ -242,7 +242,7 @@ ;;; ### For functions with XEPs, name could be represented more simply ;;; and compactly as some sort of info about with how to find the -;;; FUNCTION-ENTRY that this is a function for. Actually, you really +;;; function entry that this is a function for. Actually, you really ;;; hardly need any info. You can just chain through the functions in ;;; the component until you find the right one. Well, I guess you need ;;; to at least know which function is an XEP for the real function diff --git a/src/code/early-setf.lisp b/src/code/early-setf.lisp index e532da6..709ba8e 100644 --- a/src/code/early-setf.lisp +++ b/src/code/early-setf.lisp @@ -101,7 +101,7 @@ GET-SETF-EXPANSION directly." `(funcall #'(setf ,(car form))) t)))) -(defun get-setf-method-inverse (form inverse setf-function) +(defun get-setf-method-inverse (form inverse setf-fun) (let ((new-var (gensym)) (vars nil) (vals nil)) @@ -110,7 +110,7 @@ GET-SETF-EXPANSION directly." (push x vals)) (setq vals (nreverse vals)) (values vars vals (list new-var) - (if setf-function + (if setf-fun `(,@inverse ,new-var ,@vars) `(,@inverse ,@vars ,new-var)) `(,(car form) ,@vars)))) diff --git a/src/code/fop.lisp b/src/code/fop.lisp index 5d67fee..417a12c 100644 --- a/src/code/fop.lisp +++ b/src/code/fop.lisp @@ -650,7 +650,7 @@ bug.~:@>") (unless (zerop (logand offset sb!vm:lowtag-mask)) (error "internal error: unaligned function object, offset = #X~X" offset)) - (let ((fun (%primitive sb!c:compute-function code-object offset))) + (let ((fun (%primitive sb!c:compute-fun code-object offset))) (setf (%simple-fun-self fun) fun) (setf (%simple-fun-next fun) (%code-entry-points code-object)) (setf (%code-entry-points code-object) fun) diff --git a/src/code/kernel.lisp b/src/code/kernel.lisp index 7624d2c..08b69bb 100644 --- a/src/code/kernel.lisp +++ b/src/code/kernel.lisp @@ -56,10 +56,10 @@ (sb!c::control-stack-pointer-sap)) ;;; Return the header typecode for FUNCTION. Can be set with SETF. -(defun function-subtype (function) - (function-subtype function)) -(defun (setf function-subtype) (type function) - (setf (function-subtype function) type)) +(defun fun-subtype (function) + (fun-subtype function)) +(defun (setf fun-subtype) (type function) + (setf (fun-subtype function) type)) ;;; Extract the arglist from the function header FUNC. (defun %simple-fun-arglist (func) diff --git a/src/code/ntrace.lisp b/src/code/ntrace.lisp index d4e2158..7552b2b 100644 --- a/src/code/ntrace.lisp +++ b/src/code/ntrace.lisp @@ -36,7 +36,7 @@ ;;;; internal state ;;; a hash table that maps each traced function to the TRACE-INFO. The -;;; entry for a closure is the shared function-entry object. +;;; entry for a closure is the shared function entry object. (defvar *traced-funs* (make-hash-table :test 'eq)) ;;; A TRACE-INFO object represents all the information we need to diff --git a/src/code/print.lisp b/src/code/print.lisp index a7d4ed2..5b1ae05 100644 --- a/src/code/print.lisp +++ b/src/code/print.lisp @@ -1575,7 +1575,7 @@ (*print-level* 3) ; ..print an interpreted function definition ;; FIXME: This find-the-function-name idiom ought to be ;; encapsulated in a function somewhere. - (name (case (function-subtype object) + (name (case (fun-subtype object) (#.sb!vm:closure-header-widetag "CLOSURE") (#.sb!vm:simple-fun-header-widetag (%simple-fun-name object)) (t 'no-name-available))) diff --git a/src/code/save.lisp b/src/code/save.lisp index 772fa8e..ea67cfb 100644 --- a/src/code/save.lisp +++ b/src/code/save.lisp @@ -19,7 +19,7 @@ (sb!alien:define-alien-routine "save" (sb!alien:boolean) (file sb!c-call:c-string) - (initial-function (sb!alien:unsigned #.sb!vm:n-word-bits))) + (initial-fun (sb!alien:unsigned #.sb!vm:n-word-bits))) ;;; FIXME: When this is run without the PURIFY option, ;;; it seems to save memory all the way up to the high-water mark, diff --git a/src/code/seq.lisp b/src/code/seq.lisp index 12df112..fbb59c6 100644 --- a/src/code/seq.lisp +++ b/src/code/seq.lisp @@ -760,7 +760,7 @@ ;;; length of the output sequence matches any length specified ;;; in RESULT-TYPE. (defun %map (result-type function first-sequence &rest more-sequences) - (let ((really-function (%coerce-callable-to-fun function))) + (let ((really-fun (%coerce-callable-to-fun function))) ;; Handle one-argument MAP NIL specially, using ETYPECASE to turn ;; it into something which can be DEFTRANSFORMed away. (It's ;; fairly important to handle this case efficiently, since @@ -768,21 +768,21 @@ ;; there's no consing overhead to dwarf our inefficiency.) (if (and (null more-sequences) (null result-type)) - (%map-for-effect-arity-1 really-function first-sequence) + (%map-for-effect-arity-1 really-fun first-sequence) ;; Otherwise, use the industrial-strength full-generality ;; approach, consing O(N-ARGS) temporary storage (which can have ;; DYNAMIC-EXTENT), then using O(N-ARGS * RESULT-LENGTH) time. (let ((sequences (cons first-sequence more-sequences))) (case (type-specifier-atom result-type) - ((nil) (%map-for-effect really-function sequences)) - (list (%map-to-list really-function sequences)) + ((nil) (%map-for-effect really-fun sequences)) + (list (%map-to-list really-fun sequences)) ((simple-vector simple-string vector string array simple-array bit-vector simple-bit-vector base-string simple-base-string) - (%map-to-vector result-type really-function sequences)) + (%map-to-vector result-type really-fun sequences)) (t (apply #'map (result-type-or-lose result-type t) - really-function + really-fun sequences))))))) (defun map (result-type function first-sequence &rest more-sequences) diff --git a/src/compiler/aliencomp.lisp b/src/compiler/aliencomp.lisp index ead78df..d2a98d5 100644 --- a/src/compiler/aliencomp.lisp +++ b/src/compiler/aliencomp.lisp @@ -470,7 +470,7 @@ (let ((alien-node (continuation-use alien))) (typecase alien-node (combination - (extract-function-args alien '%sap-alien 2) + (extract-fun-args alien '%sap-alien 2) '(lambda (sap type) (declare (ignore type)) sap)) @@ -582,7 +582,7 @@ (unless (and (constant-continuation-p inside-amount) (not (minusp (continuation-value inside-amount)))) (give-up-ir1-transform))))) - (extract-function-args value 'ash 2) + (extract-fun-args value 'ash 2) '(lambda (value amount1 amount2) (ash value (+ amount1 amount2)))) diff --git a/src/compiler/alpha/call.lisp b/src/compiler/alpha/call.lisp index f59202c..821483a 100644 --- a/src/compiler/alpha/call.lisp +++ b/src/compiler/alpha/call.lisp @@ -132,7 +132,7 @@ ;; Make sure the function is aligned, and drop a label pointing to ;; this function header. (align n-lowtag-bits) - (trace-table-entry trace-table-function-prologue) + (trace-table-entry trace-table-fun-prologue) (emit-label start-lab) ;; Allocate function header. (inst simple-fun-header-word) @@ -163,7 +163,7 @@ (nfp :scs (any-reg))) (:info callee) (:generator 2 - (trace-table-entry trace-table-function-prologue) + (trace-table-entry trace-table-fun-prologue) (move csp-tn res) (inst lda csp-tn @@ -541,7 +541,7 @@ default-value-8 (:ignore val-locs vals) (:vop-var vop) (:generator 6 - (trace-table-entry trace-table-function-epilogue) + (trace-table-entry trace-table-fun-epilogue) (maybe-load-stack-tn ocfp-temp ocfp) (maybe-load-stack-tn return-pc-temp return-pc) (move cfp-tn csp-tn) @@ -885,7 +885,7 @@ default-value-8 (:vop-var vop) (:generator 6 ;; Clear the number stack. - (trace-table-entry trace-table-function-epilogue) + (trace-table-entry trace-table-fun-epilogue) (let ((cur-nfp (current-nfp-tn vop))) (when cur-nfp (inst addq cur-nfp (bytes-needed-for-non-descriptor-stack-frame) @@ -936,7 +936,7 @@ default-value-8 (:vop-var vop) (:generator 6 ;; Clear the number stack. - (trace-table-entry trace-table-function-epilogue) + (trace-table-entry trace-table-fun-epilogue) (let ((cur-nfp (current-nfp-tn vop))) (when cur-nfp (inst addq cur-nfp (bytes-needed-for-non-descriptor-stack-frame) @@ -983,7 +983,7 @@ default-value-8 (:vop-var vop) (:generator 13 - (trace-table-entry trace-table-function-epilogue) + (trace-table-entry trace-table-fun-epilogue) (let ((not-single (gen-label))) ;; Clear the number stack. (let ((cur-nfp (current-nfp-tn vop))) diff --git a/src/compiler/alpha/parms.lisp b/src/compiler/alpha/parms.lisp index a73dc08..0eca5b9 100644 --- a/src/compiler/alpha/parms.lisp +++ b/src/compiler/alpha/parms.lisp @@ -146,8 +146,8 @@ (defenum (:prefix trace-table-) normal call-site - function-prologue - function-epilogue) + fun-prologue + fun-epilogue) ;;;; static symbols diff --git a/src/compiler/alpha/system.lisp b/src/compiler/alpha/system.lisp index e87277a..f6d3305 100644 --- a/src/compiler/alpha/system.lisp +++ b/src/compiler/alpha/system.lisp @@ -57,8 +57,8 @@ DONE)) -(define-vop (function-subtype) - (:translate function-subtype) +(define-vop (fun-subtype) + (:translate fun-subtype) (:policy :fast-safe) (:args (function :scs (descriptor-reg))) (:results (result :scs (unsigned-reg))) @@ -66,8 +66,8 @@ (:generator 6 (load-type result function (- fun-pointer-lowtag)))) -(define-vop (set-function-subtype) - (:translate (setf function-subtype)) +(define-vop (set-fun-subtype) + (:translate (setf fun-subtype)) (:policy :fast-safe) (:args (type :scs (unsigned-reg) :target result) (function :scs (descriptor-reg))) @@ -199,7 +199,7 @@ (inst subq ndescr other-pointer-lowtag ndescr) (inst addq code ndescr sap))) -(define-vop (compute-function) +(define-vop (compute-fun) (:args (code :scs (descriptor-reg)) (offset :scs (signed-reg unsigned-reg))) (:arg-types * positive-fixnum) diff --git a/src/compiler/checkgen.lisp b/src/compiler/checkgen.lisp index 01f8e29..fa280ab 100644 --- a/src/compiler/checkgen.lisp +++ b/src/compiler/checkgen.lisp @@ -29,7 +29,7 @@ (let ((info (info :function :info name)) (call-cost (template-cost (template-or-lose 'call-named)))) (if info - (let ((templates (function-info-templates info))) + (let ((templates (fun-info-templates info))) (if templates (template-cost (first templates)) (case name @@ -276,12 +276,12 @@ (cond ((eq cont (basic-combination-fun dest)) t) ((eq kind :local) t) ((member kind '(:full :error)) nil) - ((function-info-ir2-convert kind) t) + ((fun-info-ir2-convert kind) t) (t - (dolist (template (function-info-templates kind) nil) + (dolist (template (fun-info-templates kind) nil) (when (eq (template-ltn-policy template) :fast-safe) (multiple-value-bind (val win) - (valid-function-use dest (template-type template)) + (valid-fun-use dest (template-type template)) (when (or val (not win)) (return t))))))))) (t t)))) @@ -431,7 +431,7 @@ (values)) ;;; Mark CONT as being a continuation with a manifest type error. We -;;; set the kind to :ERROR, and clear any FUNCTION-INFO if the +;;; set the kind to :ERROR, and clear any FUN-INFO if the ;;; continuation is an argument to a known call. The last is done so ;;; that the back end doesn't have to worry about type errors in ;;; arguments to known functions. This clearing is inhibited for @@ -444,8 +444,8 @@ (when (and (combination-p dest) (let ((kind (basic-combination-kind dest))) (or (eq kind :full) - (and (function-info-p kind) - (not (function-info-ir2-convert kind)))))) + (and (fun-info-p kind) + (not (fun-info-ir2-convert kind)))))) (setf (basic-combination-kind dest) :error))) (values)) diff --git a/src/compiler/ctype.lisp b/src/compiler/ctype.lisp index 35538ca..34d69f0 100644 --- a/src/compiler/ctype.lisp +++ b/src/compiler/ctype.lisp @@ -102,12 +102,12 @@ ;;; explain the result. We bind *COMPILER-ERROR-CONTEXT* to the ;;; combination node so that COMPILER-WARNING and related functions ;;; will do the right thing if they are supplied. -(defun valid-function-use (call type &key - ((:argument-test *ctype-test-fun*) #'csubtypep) - (result-test #'values-subtypep) - (strict-result nil) - ((:lossage-fun *lossage-fun*)) - ((:unwinnage-fun *unwinnage-fun*))) +(defun valid-fun-use (call type &key + ((:argument-test *ctype-test-fun*) #'csubtypep) + (result-test #'values-subtypep) + (strict-result nil) + ((:lossage-fun *lossage-fun*)) + ((:unwinnage-fun *unwinnage-fun*))) (declare (type function result-test) (type combination call) (type fun-type type)) (let* ((*lossage-detected* nil) diff --git a/src/compiler/debug.lisp b/src/compiler/debug.lisp index 6463f64..7553f5d 100644 --- a/src/compiler/debug.lisp +++ b/src/compiler/debug.lisp @@ -52,10 +52,12 @@ ;;; *SEEN-BLOCKS* is a hashtable with true values for all blocks which ;;; appear in the DFO for one of the specified components. ;;; -;;; *SEEN-FUNCTIONS* is similar, but records all the lambdas we +;;; *SEEN-FUNS* is similar, but records all the lambdas we ;;; reached by recursing on top level functions. +;;; FIXME: Is it really only LAMBDAs, not e.g. FUNCTIONALs? Then +;;; shouldn't it be *SEEN-LAMBDAS*? (defvar *seen-blocks* (make-hash-table :test 'eq)) -(defvar *seen-functions* (make-hash-table :test 'eq)) +(defvar *seen-funs* (make-hash-table :test 'eq)) ;;; Barf if NODE is in a block which wasn't reached during the graph ;;; walk. @@ -68,7 +70,7 @@ ;;; Check everything that we can think of for consistency. When a ;;; definite inconsistency is detected, we BARF. Possible problems ;;; just cause us to BURP. Our argument is a list of components, but -;;; we also look at the *FREE-VARIABLES*, *FREE-FUNCTIONS* and +;;; we also look at the *FREE-VARIABLES*, *FREE-FUNS* and ;;; *CONSTANTS*. ;;; ;;; First we do a pre-pass which finds all the CBLOCKs and CLAMBDAs, @@ -79,7 +81,7 @@ (declaim (ftype (function (list) (values)) check-ir1-consistency)) (defun check-ir1-consistency (components) (clrhash *seen-blocks*) - (clrhash *seen-functions*) + (clrhash *seen-funs*) (dolist (c components) (let* ((head (component-head c)) (tail (component-tail c))) @@ -142,11 +144,11 @@ (unless (or (functional-p v) (and (global-var-p v) (eq (global-var-kind v) :global-function))) - (barf "strange *FREE-FUNCTIONS* entry: ~S" v)) + (barf "strange *FREE-FUNS* entry: ~S" v)) (dolist (n (leaf-refs v)) (check-node-reached n))) - *free-functions*) - (clrhash *seen-functions*) + *free-funs*) + (clrhash *seen-funs*) (clrhash *seen-blocks*) (values)) @@ -154,15 +156,15 @@ (defun observe-functional (x) (declare (type functional x)) - (when (gethash x *seen-functions*) + (when (gethash x *seen-funs*) (barf "~S was seen more than once." x)) (unless (eq (functional-kind x) :deleted) - (setf (gethash x *seen-functions*) t))) + (setf (gethash x *seen-funs*) t))) ;;; Check that the specified function has been seen. (defun check-fun-reached (fun where) (declare (type functional fun)) - (unless (gethash fun *seen-functions*) + (unless (gethash fun *seen-funs*) (barf "unseen function ~S in ~S" fun where))) ;;; In a CLAMBDA, check that the associated nodes are in seen blocks. @@ -926,7 +928,7 @@ (integer (continuation-block (num-cont thing))) (functional (lambda-block (main-entry thing))) (null (error "Bad thing: ~S." thing)) - (symbol (block-or-lose (gethash thing *free-functions*))))) + (symbol (block-or-lose (gethash thing *free-funs*))))) ;;; Print cN. (defun print-continuation (cont) @@ -951,7 +953,7 @@ (basic-combination (let ((kind (basic-combination-kind node))) (format t "~(~A ~A~) c~D" - (if (function-info-p kind) "known" kind) + (if (fun-info-p kind) "known" kind) (type-of node) (cont-num (basic-combination-fun node))) (dolist (arg (basic-combination-args node)) diff --git a/src/compiler/disassem.lisp b/src/compiler/disassem.lisp index 6d8e469..00702e2 100644 --- a/src/compiler/disassem.lisp +++ b/src/compiler/disassem.lisp @@ -427,7 +427,7 @@ (munge-fun-refs (cddr override) evalp))) overrides)) -(defparameter *arg-function-params* +(defparameter *arg-fun-params* '((:printer . (value stream dstate)) (:use-label . (value dstate)) (:prefilter . (value dstate)))) @@ -438,7 +438,7 @@ (wrapper-defs nil)) ((null tail) (values params (nreverse wrapper-defs))) - (let ((fun-arg (assoc (car tail) *arg-function-params*))) + (let ((fun-arg (assoc (car tail) *arg-fun-params*))) (when fun-arg (let* ((fun-form (cadr tail)) (quoted-fun-form `',fun-form)) @@ -989,13 +989,13 @@ (valsrc-value thing) thing)) -(defstruct (cached-function (:conc-name cached-fun-) - (:copier nil)) +(defstruct (cached-fun (:conc-name cached-fun-) + (:copier nil)) (funstate nil :type (or null funstate)) (constraint nil :type list) (name nil :type (or null symbol))) -(defun find-cached-function (cached-funs args constraint) +(defun find-cached-fun (cached-funs args constraint) (dolist (cached-fun cached-funs nil) (let ((funstate (cached-fun-funstate cached-fun))) (when (and (equal constraint (cached-fun-constraint cached-fun)) @@ -1003,29 +1003,29 @@ (funstate-compatible-p funstate args))) (return cached-fun))))) -(defmacro !with-cached-function ((name-var - funstate-var - cache - cache-slot - args - &key - constraint - (stem (missing-arg))) - &body defun-maker-forms) +(defmacro !with-cached-fun ((name-var + funstate-var + cache + cache-slot + args + &key + constraint + (stem (missing-arg))) + &body defun-maker-forms) (let ((cache-var (gensym)) (constraint-var (gensym))) `(let* ((,constraint-var ,constraint) - (,cache-var (find-cached-function (,cache-slot ,cache) - ,args ,constraint-var))) + (,cache-var (find-cached-fun (,cache-slot ,cache) + ,args ,constraint-var))) (cond (,cache-var (values (cached-fun-name ,cache-var) nil)) (t (let* ((,name-var (symbolicate "CACHED-FUN--" ,stem)) (,funstate-var (make-funstate ,args)) (,cache-var - (make-cached-function :name ,name-var - :funstate ,funstate-var - :constraint ,constraint-var))) + (make-cached-fun :name ,name-var + :funstate ,funstate-var + :constraint ,constraint-var))) (values ,name-var `(progn ,(progn ,@defun-maker-forms) @@ -1038,7 +1038,7 @@ (if (null printer-source) (values nil nil) (let ((printer-source (preprocess-printer printer-source args))) - (!with-cached-function + (!with-cached-fun (name funstate cache fun-cache-printers args :constraint printer-source :stem (concatenate 'string @@ -1411,7 +1411,7 @@ (mapcar #'arg-name (remove-if-not #'arg-use-label args)))) (if (null labelled-fields) (values nil nil) - (!with-cached-function + (!with-cached-fun (name funstate cache fun-cache-labellers args :stem (concatenate 'string "LABELLER-" (string %name)) :constraint labelled-fields) @@ -1449,7 +1449,7 @@ (remove-if-not #'arg-prefilter args)))) (if (null filtered-args) (values nil nil) - (!with-cached-function + (!with-cached-fun (name funstate cache fun-cache-prefilters args :stem (concatenate 'string (string %name) diff --git a/src/compiler/dump.lisp b/src/compiler/dump.lisp index 4946783..eaa958e 100644 --- a/src/compiler/dump.lisp +++ b/src/compiler/dump.lisp @@ -1075,7 +1075,7 @@ (dump-fop 'fop-sanctify-for-execution file) (dump-pop file)) -;;; Dump a function-entry data structure corresponding to ENTRY to +;;; Dump a function entry data structure corresponding to ENTRY to ;;; FILE. CODE-HANDLE is the table offset of the code object for the ;;; component. (defun dump-one-entry (entry code-handle file) diff --git a/src/compiler/early-c.lisp b/src/compiler/early-c.lisp index c82c568..acf0085 100644 --- a/src/compiler/early-c.lisp +++ b/src/compiler/early-c.lisp @@ -74,11 +74,11 @@ (declaim (type lexenv *lexenv*)) ;;; *FREE-VARIABLES* translates from the names of variables referenced -;;; globally to the LEAF structures for them. *FREE-FUNCTIONS* is like +;;; globally to the LEAF structures for them. *FREE-FUNS* is like ;;; *FREE-VARIABLES*, only it deals with function names. (defvar *free-variables*) -(defvar *free-functions*) -(declaim (type hash-table *free-variables* *free-functions*)) +(defvar *free-funs*) +(declaim (type hash-table *free-variables* *free-funs*)) ;;; We use the same CONSTANT structure to represent all equal anonymous ;;; constants. This hashtable translates from constants to the LEAFs that diff --git a/src/compiler/float-tran.lisp b/src/compiler/float-tran.lisp index a65bf35..2b2495d 100644 --- a/src/compiler/float-tran.lisp +++ b/src/compiler/float-tran.lisp @@ -319,7 +319,7 @@ (sqrt (real 0.0)))) (destructuring-bind (name type) stuff (let ((type (specifier-type type))) - (setf (function-info-derive-type (function-info-or-lose name)) + (setf (fun-info-derive-type (fun-info-or-lose name)) (lambda (call) (declare (type combination call)) (when (csubtypep (continuation-type diff --git a/src/compiler/generic/core.lisp b/src/compiler/generic/core.lisp index 8ea0cbd..329f5a2 100644 --- a/src/compiler/generic/core.lisp +++ b/src/compiler/generic/core.lisp @@ -65,9 +65,9 @@ (values (get-lisp-obj-address code) t))))) (sb!vm:fixup-code-object code offset value kind)))) -;;; Stick a reference to the function Fun in Code-Object at index I. If the -;;; function hasn't been compiled yet, make a note in the Patch-Table. -(defun reference-core-function (code-obj i fun object) +;;; Stick a reference to the function FUN in CODE-OBJECT at index I. If the +;;; function hasn't been compiled yet, make a note in the patch table. +(defun reference-core-fun (code-obj i fun object) (declare (type core-object object) (type functional fun) (type index i)) (let* ((info (leaf-info fun)) diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp index c46ffbb..fa0dc2f 100644 --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@ -2738,7 +2738,7 @@ initially undefined function references:~2%") (defparameter validate-entry-type-code 3845) (defparameter directory-entry-type-code 3841) (defparameter new-directory-entry-type-code 3861) -(defparameter initial-function-entry-type-code 3863) +(defparameter initial-fun-entry-type-code 3863) (defparameter end-entry-type-code 3840) (declaim (ftype (function (sb!vm:word) sb!vm:word) write-long)) @@ -2838,16 +2838,16 @@ initially undefined function references:~2%") (output-gspace *dynamic*) ;; Write the initial function. - (write-long initial-function-entry-type-code) + (write-long initial-fun-entry-type-code) (write-long 3) (let* ((cold-name (cold-intern '!cold-init)) (cold-fdefn (cold-fdefinition-object cold-name)) - (initial-function (read-wordindexed cold-fdefn - sb!vm:fdefn-fun-slot))) + (initial-fun (read-wordindexed cold-fdefn + sb!vm:fdefn-fun-slot))) (format t - "~&/(DESCRIPTOR-BITS INITIAL-FUNCTION)=#X~X~%" - (descriptor-bits initial-function)) - (write-long (descriptor-bits initial-function))) + "~&/(DESCRIPTOR-BITS INITIAL-FUN)=#X~X~%" + (descriptor-bits initial-fun)) + (write-long (descriptor-bits initial-fun))) ;; Write the End entry. (write-long end-entry-type-code) diff --git a/src/compiler/generic/target-core.lisp b/src/compiler/generic/target-core.lisp index aedc131..025e376 100644 --- a/src/compiler/generic/target-core.lisp +++ b/src/compiler/generic/target-core.lisp @@ -17,21 +17,21 @@ (in-package "SB!C") ;;; Make a function entry, filling in slots from the ENTRY-INFO. -(defun make-function-entry (entry code-obj object) - (declare (type entry-info entry) (type core-object object)) - (let ((offset (label-position (entry-info-offset entry)))) +(defun make-fun-entry (entry-info code-obj object) + (declare (type entry-info entry-info) (type core-object object)) + (let ((offset (label-position (entry-info-offset entry-info)))) (declare (type index offset)) (unless (zerop (logand offset sb!vm:lowtag-mask)) (error "Unaligned function object, offset = #X~X." offset)) - (let ((res (%primitive compute-function code-obj offset))) + (let ((res (%primitive compute-fun code-obj offset))) (setf (%simple-fun-self res) res) (setf (%simple-fun-next res) (%code-entry-points code-obj)) (setf (%code-entry-points code-obj) res) - (setf (%simple-fun-name res) (entry-info-name entry)) - (setf (%simple-fun-arglist res) (entry-info-arguments entry)) - (setf (%simple-fun-type res) (entry-info-type entry)) + (setf (%simple-fun-name res) (entry-info-name entry-info)) + (setf (%simple-fun-arglist res) (entry-info-arguments entry-info)) + (setf (%simple-fun-type res) (entry-info-type entry-info)) - (note-fun entry res object)))) + (note-fun entry-info res object)))) ;;; Dump a component to core. We pass in the assembler fixups, code ;;; vector and node info. @@ -74,7 +74,7 @@ (do-core-fixups code-obj fixups) (dolist (entry (ir2-component-entries 2comp)) - (make-function-entry entry code-obj object)) + (make-fun-entry entry code-obj object)) (sb!vm:sanctify-for-execution code-obj) @@ -101,8 +101,7 @@ (list (ecase (car const) (:entry - (reference-core-function code-obj index - (cdr const) object)) + (reference-core-fun code-obj index (cdr const) object)) (:fdefinition (setf (code-header-ref code-obj index) (fdefinition-object (cdr const) t)))))))))) diff --git a/src/compiler/generic/vm-fndb.lisp b/src/compiler/generic/vm-fndb.lisp index 4ade63d..2d50d2a 100644 --- a/src/compiler/generic/vm-fndb.lisp +++ b/src/compiler/generic/vm-fndb.lisp @@ -272,9 +272,9 @@ (defknown code-header-ref (t index) t (flushable)) (defknown code-header-set (t index t) t ()) -(defknown function-subtype (function) (unsigned-byte #.sb!vm:n-widetag-bits) +(defknown fun-subtype (function) (unsigned-byte #.sb!vm:n-widetag-bits) (flushable)) -(defknown ((setf function-subtype)) +(defknown ((setf fun-subtype)) ((unsigned-byte #.sb!vm:n-widetag-bits) function) (unsigned-byte #.sb!vm:n-widetag-bits) ()) diff --git a/src/compiler/generic/vm-macs.lisp b/src/compiler/generic/vm-macs.lisp index 07dd18f..b40ddff 100644 --- a/src/compiler/generic/vm-macs.lisp +++ b/src/compiler/generic/vm-macs.lisp @@ -129,8 +129,8 @@ (in-package "SB!C") (defun %def-reffer (name offset lowtag) - (let ((info (function-info-or-lose name))) - (setf (function-info-ir2-convert info) + (let ((info (fun-info-or-lose name))) + (setf (fun-info-ir2-convert info) (lambda (node block) (ir2-convert-reffer node block name offset lowtag)))) name) @@ -139,8 +139,8 @@ `(%def-reffer ',name ,offset ,lowtag)) (defun %def-setter (name offset lowtag) - (let ((info (function-info-or-lose name))) - (setf (function-info-ir2-convert info) + (let ((info (fun-info-or-lose name))) + (setf (fun-info-ir2-convert info) (if (listp name) (lambda (node block) (ir2-convert-setfer node block name offset lowtag)) @@ -152,8 +152,8 @@ `(%def-setter ',name ,offset ,lowtag)) (defun %def-alloc (name words var-length header lowtag inits) - (let ((info (function-info-or-lose name))) - (setf (function-info-ir2-convert info) + (let ((info (fun-info-or-lose name))) + (setf (fun-info-ir2-convert info) (if var-length (lambda (node block) (ir2-convert-variable-allocation node block name words header diff --git a/src/compiler/globaldb.lisp b/src/compiler/globaldb.lisp index cd2e53c..ae0442c 100644 --- a/src/compiler/globaldb.lisp +++ b/src/compiler/globaldb.lisp @@ -1125,13 +1125,12 @@ :type :ir1-transform :type-spec (or function null)) -;;; If a function is "known" to the compiler, then this is a -;;; FUNCTION-INFO structure containing the info used to special-case -;;; compilation. +;;; If a function is "known" to the compiler, then this is a FUN-INFO +;;; structure containing the info used to special-case compilation. (define-info-type :class :function :type :info - :type-spec (or function-info null) + :type-spec (or fun-info null) :default nil) (define-info-type diff --git a/src/compiler/info-functions.lisp b/src/compiler/info-functions.lisp index ab6cc28..fa435c7 100644 --- a/src/compiler/info-functions.lisp +++ b/src/compiler/info-functions.lisp @@ -60,12 +60,12 @@ ;; in EVAL-WHEN (:COMPILE) inside something like DEFSTRUCT, in which ;; case it's reasonable style. Either way, NAME is no longer a free ;; function.) - (when (boundp '*free-functions*) ; when compiling - (remhash name *free-functions*)) + (when (boundp '*free-funs*) ; when compiling + (remhash name *free-funs*)) ;; recording the ordinary case (setf (info :function :kind name) :function) - (note-if-setf-function-and-macro name) + (note-if-setf-fun-and-macro name) (values)) @@ -75,7 +75,7 @@ ;;; warning. Due to the weak semantics of the (SETF FUNCTION) name, we ;;; can't assume that they aren't just naming a function (SETF FOO) ;;; for the heck of it. NAME is already known to be well-formed. -(defun note-if-setf-function-and-macro (name) +(defun note-if-setf-fun-and-macro (name) (when (consp name) (when (or (info :setf :inverse name) (info :setf :expander name)) diff --git a/src/compiler/ir1-translators.lisp b/src/compiler/ir1-translators.lisp index a1c9556..50efcc3 100644 --- a/src/compiler/ir1-translators.lisp +++ b/src/compiler/ir1-translators.lisp @@ -422,7 +422,7 @@ :debug-name (debug-namify "#'~S" thing)))) ((setf) - (let ((var (find-lexically-apparent-function + (let ((var (find-lexically-apparent-fun thing "as the argument to FUNCTION"))) (reference-leaf start cont var))) ((instance-lambda) @@ -433,7 +433,7 @@ (reference-leaf start cont res))) (t (compiler-error "~S is not a legal function name." thing))) - (let ((var (find-lexically-apparent-function + (let ((var (find-lexically-apparent-fun thing "as the argument to FUNCTION"))) (reference-leaf start cont var)))) @@ -868,7 +868,7 @@ ;;; ;;; Note that environment analysis replaces references to escape ;;; functions with references to the corresponding NLX-INFO structure. -(def-ir1-translator %escape-function ((tag) start cont) +(def-ir1-translator %escape-fun ((tag) start cont) (let ((fun (ir1-convert-lambda `(lambda () (return-from ,tag (%unknown-values))) @@ -879,7 +879,7 @@ ;;; Yet another special special form. This one looks up a local ;;; function and smashes it to a :CLEANUP function, as well as ;;; referencing it. -(def-ir1-translator %cleanup-function ((name) start cont) +(def-ir1-translator %cleanup-fun ((name) start cont) (let ((fun (lexenv-find name functions))) (aver (lambda-p fun)) (setf (functional-kind fun) :cleanup) @@ -901,13 +901,13 @@ `(block ,exit-block (%within-cleanup :catch - (%catch (%escape-function ,exit-block) ,tag) + (%catch (%escape-fun ,exit-block) ,tag) ,@body))))) ;;; UNWIND-PROTECT is similar to CATCH, but hairier. We make the ;;; cleanup forms into a local function so that they can be referenced ;;; both in the case where we are unwound and in any local exits. We -;;; use %CLEANUP-FUNCTION on this to indicate that reference by +;;; use %CLEANUP-FUN on this to indicate that reference by ;;; %UNWIND-PROTECT isn't "real", and thus doesn't cause creation of ;;; an XEP. (def-ir1-translator unwind-protect ((protected &body cleanup) start cont) @@ -927,15 +927,15 @@ `(flet ((,cleanup-fun () ,@cleanup nil)) ;; FIXME: If we ever get DYNAMIC-EXTENT working, then ;; ,CLEANUP-FUN should probably be declared DYNAMIC-EXTENT, - ;; and something can be done to make %ESCAPE-FUNCTION have + ;; and something can be done to make %ESCAPE-FUN have ;; dynamic extent too. (block ,drop-thru-tag (multiple-value-bind (,next ,start ,count) (block ,exit-tag (%within-cleanup :unwind-protect - (%unwind-protect (%escape-function ,exit-tag) - (%cleanup-function ,cleanup-fun)) + (%unwind-protect (%escape-fun ,exit-tag) + (%cleanup-fun ,cleanup-fun)) (return-from ,drop-thru-tag ,protected))) (,cleanup-fun) (%continue-unwind ,next ,start ,count))))))) @@ -1078,7 +1078,7 @@ (ecase (info :function :kind name) ((nil)) (:function - (remhash name *free-functions*) + (remhash name *free-funs*) (undefine-fun-name name) (compiler-warn "~S is being redefined as a macro when it was ~ diff --git a/src/compiler/ir1final.lisp b/src/compiler/ir1final.lisp index 7f20246..055322b 100644 --- a/src/compiler/ir1final.lisp +++ b/src/compiler/ir1final.lisp @@ -20,7 +20,7 @@ (defun note-failed-optimization (node failures) (declare (type combination node) (list failures)) (unless (or (node-deleted node) - (not (function-info-p (combination-kind node)))) + (not (fun-info-p (combination-kind node)))) (let ((*compiler-error-context* node)) (dolist (failure failures) (let ((what (cdr failure)) @@ -29,16 +29,16 @@ ((consp what) (compiler-note "~@" note (first what) (rest what))) - ((valid-function-use node what - :argument-test #'types-equal-or-intersect - :result-test #'values-types-equal-or-intersect) + ((valid-fun-use node what + :argument-test #'types-equal-or-intersect + :result-test #'values-types-equal-or-intersect) (collect ((messages)) (flet ((give-grief (string &rest stuff) (messages string) (messages stuff))) - (valid-function-use node what - :unwinnage-fun #'give-grief - :lossage-fun #'give-grief)) + (valid-fun-use node what + :unwinnage-fun #'give-grief + :lossage-fun #'give-grief)) (compiler-note "~@" - old-function-info name))) + "~@" + old-fun-info name))) (setf (info :function :type name target-env) ctype) (setf (info :function :where-from name target-env) :declared) (setf (info :function :kind name target-env) :function) (setf (info :function :info name target-env) info))) names) -;;; Return the FUNCTION-INFO for NAME or die trying. Since this is +;;; Return the FUN-INFO for NAME or die trying. Since this is ;;; used by callers who want to modify the info, and the info may be ;;; shared, we copy it. We don't have to copy the lists, since each ;;; function that has generators or transforms has already been ;;; through here. -(declaim (ftype (function (t) function-info) function-info-or-lose)) -(defun function-info-or-lose (name) +(declaim (ftype (function (t) fun-info) fun-info-or-lose)) +(defun fun-info-or-lose (name) (let (;; FIXME: Do we need this rebinding here? It's a literal ;; translation of the old CMU CL rebinding to ;; (OR *BACKEND-INFO-ENVIRONMENT* *INFO-ENVIRONMENT*), @@ -211,7 +211,7 @@ (*info-environment* *info-environment*)) (let ((old (info :function :info name))) (unless old (error "~S is not a known function." name)) - (setf (info :function :info name) (copy-function-info old))))) + (setf (info :function :info name) (copy-fun-info old))))) ;;;; generic type inference methods diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index 7a0b50d..9bdfc37 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -941,7 +941,7 @@ ;;; work. We change the CALL's CONT to be the continuation heading the ;;; BIND block, and also do REOPTIMIZE-CONTINUATION on the args and ;;; CONT so that LET-specific IR1 optimizations get a chance. We blow -;;; away any entry for the function in *FREE-FUNCTIONS* so that nobody +;;; away any entry for the function in *FREE-FUNS* so that nobody ;;; will create new references to it. (defun let-convert (fun call) (declare (type clambda fun) (type basic-combination call)) diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp index fe64801..55ff009 100644 --- a/src/compiler/ltn.lisp +++ b/src/compiler/ltn.lisp @@ -140,7 +140,7 @@ ;;; Unlike for an argument, we only clear the type check flag when the ;;; LTN-POLICY is unsafe, since the check for a valid function ;;; object must be done before the call. -(defun annotate-function-continuation (cont ltn-policy &optional (delay t)) +(defun annotate-fun-continuation (cont ltn-policy &optional (delay t)) (declare (type continuation cont) (type ltn-policy ltn-policy)) (unless (ltn-policy-safe-p ltn-policy) (flush-type-check cont)) @@ -193,11 +193,11 @@ (defun ltn-default-call (call ltn-policy) (declare (type combination call) (type ltn-policy ltn-policy)) (let ((kind (basic-combination-kind call))) - (annotate-function-continuation (basic-combination-fun call) ltn-policy) + (annotate-fun-continuation (basic-combination-fun call) ltn-policy) (cond - ((and (function-info-p kind) - (function-info-ir2-convert kind)) + ((and (fun-info-p kind) + (fun-info-ir2-convert kind)) (setf (basic-combination-info call) :funny) (setf (node-tail-p call) nil) (dolist (arg (basic-combination-args call)) @@ -389,9 +389,9 @@ (setf (node-tail-p call) nil)) (t (setf (basic-combination-info call) :full) - (annotate-function-continuation (basic-combination-fun call) - ltn-policy - nil) + (annotate-fun-continuation (basic-combination-fun call) + ltn-policy + nil) (dolist (arg (reverse args)) (annotate-unknown-values-continuation arg ltn-policy)) (flush-full-call-tail-transfer call)))) @@ -679,7 +679,7 @@ (declare (type combination call) (type ltn-policy ltn-policy)) (let ((safe-p (ltn-policy-safe-p ltn-policy)) - (current (function-info-templates (basic-combination-kind call))) + (current (fun-info-templates (basic-combination-kind call))) (fallback nil) (rejected nil)) (loop @@ -783,7 +783,7 @@ (or template (template-or-lose 'call-named))) *efficiency-note-cost-threshold*))) - (dolist (try (function-info-templates (basic-combination-kind call))) + (dolist (try (fun-info-templates (basic-combination-kind call))) (when (> (template-cost try) max-cost) (return)) ; FIXME: UNLESS'd be cleaner. (let ((guard (template-guard try))) (when (and (or (not guard) (funcall guard)) @@ -791,7 +791,7 @@ (ltn-policy-safe-p (template-ltn-policy try))) (or verbose-p (and (template-note try) - (valid-function-use + (valid-fun-use call (template-type try) :argument-test #'types-equal-or-intersect :result-test @@ -810,9 +810,9 @@ (lose1 "etc.") (return)) (let* ((type (template-type loser)) - (valid (valid-function-use call type)) - (strict-valid (valid-function-use call type - :strict-result t))) + (valid (valid-fun-use call type)) + (strict-valid (valid-fun-use call type + :strict-result t))) (lose1 "unable to do ~A (cost ~W) because:" (or (template-note loser) (template-name loser)) (template-cost loser)) @@ -820,9 +820,9 @@ ((and valid strict-valid) (strange-template-failure loser call ltn-policy #'lose1)) ((not valid) - (aver (not (valid-function-use call type - :lossage-fun #'lose1 - :unwinnage-fun #'lose1)))) + (aver (not (valid-fun-use call type + :lossage-fun #'lose1 + :unwinnage-fun #'lose1)))) (t (aver (ltn-policy-safe-p ltn-policy)) (lose1 "can't trust output type assertion under safe policy"))) @@ -871,7 +871,7 @@ (defun ltn-analyze-known-call (call ltn-policy) (declare (type combination call) (type ltn-policy ltn-policy)) - (let ((method (function-info-ltn-annotate (basic-combination-kind call))) + (let ((method (fun-info-ltn-annotate (basic-combination-kind call))) (args (basic-combination-args call))) (when method (funcall method call ltn-policy) @@ -900,8 +900,8 @@ (eq (continuation-fun-name (combination-fun call)) (leaf-source-name funleaf)) (let ((info (basic-combination-kind call))) - (not (or (function-info-ir2-convert info) - (ir1-attributep (function-info-attributes info) + (not (or (fun-info-ir2-convert info) + (ir1-attributep (fun-info-attributes info) recursive)))))) (let ((*compiler-error-context* call)) (compiler-warn "~@ space speed)) diff --git a/src/compiler/x86/memory.lisp b/src/compiler/x86/memory.lisp index 10ce753..ca8c2e2 100644 --- a/src/compiler/x86/memory.lisp +++ b/src/compiler/x86/memory.lisp @@ -15,7 +15,7 @@ ;;; CELL-REF and CELL-SET are used to define VOPs like CAR, where the ;;; offset to be read or written is a property of the VOP used. ;;; CELL-SETF is similar to CELL-SET, but delivers the new value as -;;; the result. CELL-SETF-FUNCTION takes its arguments as if it were a +;;; the result. CELL-SETF-FUN takes its arguments as if it were a ;;; SETF function (new value first, as apposed to a SETF macro, which ;;; takes the new value last). (define-vop (cell-ref) @@ -41,7 +41,7 @@ (:generator 4 (storew value object offset lowtag) (move result value))) -(define-vop (cell-setf-function) +(define-vop (cell-setf-fun) (:args (value :scs (descriptor-reg any-reg) :target result) (object :scs (descriptor-reg))) (:results (result :scs (descriptor-reg any-reg))) diff --git a/src/compiler/x86/parms.lisp b/src/compiler/x86/parms.lisp index 9e31f18..d776400 100644 --- a/src/compiler/x86/parms.lisp +++ b/src/compiler/x86/parms.lisp @@ -204,8 +204,8 @@ (defenum (:prefix trace-table-) normal call-site - function-prologue - function-epilogue) + fun-prologue + fun-epilogue) ;;;; static symbols diff --git a/src/compiler/x86/system.lisp b/src/compiler/x86/system.lisp index 753f218..8644e1e 100644 --- a/src/compiler/x86/system.lisp +++ b/src/compiler/x86/system.lisp @@ -61,8 +61,8 @@ DONE (inst movzx result al-tn))) -(define-vop (function-subtype) - (:translate function-subtype) +(define-vop (fun-subtype) + (:translate fun-subtype) (:policy :fast-safe) (:args (function :scs (descriptor-reg))) (:temporary (:sc byte-reg :from (:eval 0) :to (:eval 1)) temp) @@ -72,8 +72,8 @@ (load-type temp function (- fun-pointer-lowtag)) (inst movzx result temp))) -(define-vop (set-function-subtype) - (:translate (setf function-subtype)) +(define-vop (set-fun-subtype) + (:translate (setf fun-subtype)) (:policy :fast-safe) (:args (type :scs (unsigned-reg) :target eax) (function :scs (descriptor-reg))) @@ -201,7 +201,7 @@ (inst lea sap (make-ea :byte :base code :index sap :scale 4 :disp (- other-pointer-lowtag))))) -(define-vop (compute-function) +(define-vop (compute-fun) (:args (code :scs (descriptor-reg) :to (:result 0)) (offset :scs (signed-reg unsigned-reg) :to (:result 0))) (:arg-types * positive-fixnum) diff --git a/src/pcl/boot.lisp b/src/pcl/boot.lisp index f385fb5..4c4de8d 100644 --- a/src/pcl/boot.lisp +++ b/src/pcl/boot.lisp @@ -1794,7 +1794,7 @@ bootstrapping. (when lambda-list-p (proclaim (defgeneric-declaration fun-name lambda-list))))) -(defun get-generic-function-info (gf) +(defun get-generic-fun-info (gf) ;; values nreq applyp metatypes nkeys arg-info (multiple-value-bind (applyp metatypes arg-info) (let* ((arg-info (if (early-gf-p gf) diff --git a/src/pcl/combin.lisp b/src/pcl/combin.lisp index 0a7c7d6..8ca68ca 100644 --- a/src/pcl/combin.lisp +++ b/src/pcl/combin.lisp @@ -171,7 +171,7 @@ (defun expand-effective-method-function (gf effective-method &optional env) (declare (ignore env)) (multiple-value-bind (nreq applyp metatypes nkeys arg-info) - (get-generic-function-info gf) + (get-generic-fun-info gf) (declare (ignore nreq nkeys arg-info)) (let ((ll (make-fast-method-call-lambda-list metatypes applyp)) ;; When there are no primary methods and a next-method call occurs @@ -255,7 +255,7 @@ (defun make-effective-method-function-internal (generic-function effective-method method-alist-p wrappers-p) (multiple-value-bind (nreq applyp metatypes nkeys arg-info) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore nkeys arg-info)) (let* ((*rebound-effective-method-gensyms* *global-effective-method-gensyms*) diff --git a/src/pcl/dfun.lisp b/src/pcl/dfun.lisp index c133d4f..0b7e01b 100644 --- a/src/pcl/dfun.lisp +++ b/src/pcl/dfun.lisp @@ -378,7 +378,7 @@ And so, we are saved. (when (use-dispatch-dfun-p generic-function) (return-from make-checking-dfun (make-dispatch-dfun generic-function)))) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore nreq)) (if (every (lambda (mt) (eq mt t)) metatypes) (let ((dfun-info (default-method-only-dfun-info))) @@ -412,7 +412,7 @@ And so, we are saved. (defun use-default-method-only-dfun-p (generic-function) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore nreq applyp nkeys)) (every (lambda (mt) (eq mt t)) metatypes))) @@ -445,7 +445,7 @@ And so, we are saved. (return-from make-caching-dfun (make-dispatch-dfun generic-function)))) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore nreq)) (let* ((cache (or cache (get-cache nkeys t #'caching-limit-fn 2))) (dfun-info (caching-dfun-info cache))) @@ -468,7 +468,7 @@ And so, we are saved. (defun insure-caching-dfun (gf) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info gf) + (get-generic-fun-info gf) (declare (ignore nreq nkeys)) (when (and metatypes (not (null (car metatypes))) @@ -478,7 +478,7 @@ And so, we are saved. (defun use-constant-value-dfun-p (gf &optional boolean-values-p) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info gf) + (get-generic-fun-info gf) (declare (ignore nreq metatypes nkeys)) (let* ((early-p (early-gf-p gf)) (methods (if early-p @@ -505,7 +505,7 @@ And so, we are saved. (defun make-constant-value-dfun (generic-function &optional cache) (multiple-value-bind (nreq applyp metatypes nkeys) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore nreq applyp)) (let* ((cache (or cache (get-cache nkeys t #'caching-limit-fn 2))) (dfun-info (constant-value-dfun-info cache))) @@ -967,7 +967,7 @@ And so, we are saved. ;;; in the object argument. (defun cache-miss-values (gf args state) (multiple-value-bind (nreq applyp metatypes nkeys arg-info) - (get-generic-function-info gf) + (get-generic-fun-info gf) (declare (ignore nreq applyp nkeys)) (with-dfun-wrappers (args metatypes) (dfun-wrappers invalid-wrapper-p wrappers classes types) diff --git a/src/pcl/methods.lisp b/src/pcl/methods.lisp index 9f04af7..e65ce45 100644 --- a/src/pcl/methods.lisp +++ b/src/pcl/methods.lisp @@ -598,7 +598,7 @@ (defun types-from-arguments (generic-function arguments &optional type-modifier) (multiple-value-bind (nreq applyp metatypes nkeys arg-info) - (get-generic-function-info generic-function) + (get-generic-fun-info generic-function) (declare (ignore applyp metatypes nkeys)) (let ((types-rev nil)) (dotimes-fixnum (i nreq) diff --git a/version.lisp-expr b/version.lisp-expr index 0904ae0..bf516ca 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -18,4 +18,4 @@ ;;; for internal versions, especially for internal versions off the ;;; main CVS branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) -"0.pre7.128" +"0.pre7.129" -- 1.7.10.4