0.8.15.7
[sbcl.git] / src / code / early-setf.lisp
1 ;;;; SETF and friends (except for stuff defined with COLLECT, which
2 ;;;; comes later)
3 ;;;;
4 ;;;; Note: The expansions for SETF and friends sometimes create
5 ;;;; needless LET-bindings of argument values. The compiler will
6 ;;;; remove most of these spurious bindings, so SETF doesn't worry too
7 ;;;; much about creating them.
8
9 ;;;; This software is part of the SBCL system. See the README file for
10 ;;;; more information.
11 ;;;;
12 ;;;; This software is derived from the CMU CL system, which was
13 ;;;; written at Carnegie Mellon University and released into the
14 ;;;; public domain. The software is in the public domain and is
15 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
16 ;;;; files for more information.
17
18 (in-package "SB!IMPL")
19
20 ;;; The inverse for a generalized-variable reference function is stored in
21 ;;; one of two ways:
22 ;;;
23 ;;; A SETF inverse property corresponds to the short form of DEFSETF. It is
24 ;;; the name of a function takes the same args as the reference form, plus a
25 ;;; new-value arg at the end.
26 ;;;
27 ;;; A SETF method expander is created by the long form of DEFSETF or
28 ;;; by DEFINE-SETF-EXPANDER. It is a function that is called on the reference
29 ;;; form and that produces five values: a list of temporary variables, a list
30 ;;; of value forms, a list of the single store-value form, a storing function,
31 ;;; and an accessing function.
32 (declaim (ftype (function (t &optional (or null sb!c::lexenv))) sb!xc:get-setf-expansion))
33 (defun sb!xc:get-setf-expansion (form &optional environment)
34   #!+sb-doc
35   "Return five values needed by the SETF machinery: a list of temporary
36    variables, a list of values with which to fill them, a list of temporaries
37    for the new values, the setting function, and the accessing function."
38   (let (temp)
39     (cond ((symbolp form)
40            (multiple-value-bind (expansion expanded)
41                (sb!xc:macroexpand-1 form environment)
42              (if expanded
43                  (sb!xc:get-setf-expansion expansion environment)
44                  (let ((new-var (gensym)))
45                    (values nil nil (list new-var)
46                            `(setq ,form ,new-var) form)))))
47           ;; Local functions inhibit global SETF methods.
48           ((and environment
49                 (let ((name (car form)))
50                   (dolist (x (sb!c::lexenv-funs environment))
51                     (when (and (eq (car x) name)
52                                (not (sb!c::defined-fun-p (cdr x))))
53                       (return t)))))
54            (expand-or-get-setf-inverse form environment))
55           ((setq temp (info :setf :inverse (car form)))
56            (get-setf-method-inverse form `(,temp) nil))
57           ((setq temp (info :setf :expander (car form)))
58            ;; KLUDGE: It may seem as though this should go through
59            ;; *MACROEXPAND-HOOK*, but the ANSI spec seems fairly explicit
60            ;; that *MACROEXPAND-HOOK* is a hook for MACROEXPAND-1, not
61            ;; for macroexpansion in general. -- WHN 19991128
62            (funcall temp
63                     form
64                     ;; As near as I can tell from the ANSI spec,
65                     ;; macroexpanders have a right to expect an actual
66                     ;; lexical environment, not just a NIL which is to
67                     ;; be interpreted as a null lexical environment.
68                     ;; -- WHN 19991128
69                     (coerce-to-lexenv environment)))
70           (t
71            (expand-or-get-setf-inverse form environment)))))
72
73 ;;; GET-SETF-METHOD existed in pre-ANSI Common Lisp, and various code inherited
74 ;;; from CMU CL uses it repeatedly, so rather than rewrite a lot of code to not
75 ;;; use it, we just define it in terms of ANSI's GET-SETF-EXPANSION (or
76 ;;; actually, the cross-compiler version of that, i.e.
77 ;;; SB!XC:GET-SETF-EXPANSION).
78 (declaim (ftype (function (t &optional (or null sb!c::lexenv))) get-setf-method))
79 (defun get-setf-method (form &optional environment)
80   #!+sb-doc
81   "This is a specialized-for-one-value version of GET-SETF-EXPANSION (and
82 a relic from pre-ANSI Common Lisp). Portable ANSI code should use
83 GET-SETF-EXPANSION directly."
84   (multiple-value-bind (temps value-forms store-vars store-form access-form)
85       (sb!xc:get-setf-expansion form environment)
86     (when (cdr store-vars)
87       (error "GET-SETF-METHOD used for a form with multiple store ~
88               variables:~%  ~S"
89              form))
90     (values temps value-forms store-vars store-form access-form)))
91
92 ;;; If a macro, expand one level and try again. If not, go for the
93 ;;; SETF function.
94 (declaim (ftype (function (t (or null sb!c::lexenv)))
95                 expand-or-get-setf-inverse))
96 (defun expand-or-get-setf-inverse (form environment)
97   (multiple-value-bind (expansion expanded)
98       (sb!xc:macroexpand-1 form environment)
99     (if expanded
100         (sb!xc:get-setf-expansion expansion environment)
101         (get-setf-method-inverse form
102                                  `(funcall #'(setf ,(car form)))
103                                  t))))
104
105 (defun get-setf-method-inverse (form inverse setf-fun)
106   (let ((new-var (gensym))
107         (vars nil)
108         (vals nil))
109     (dolist (x (cdr form))
110       (push (gensym) vars)
111       (push x vals))
112     (setq vals (nreverse vals))
113     (values vars vals (list new-var)
114             (if setf-fun
115                 `(,@inverse ,new-var ,@vars)
116                 `(,@inverse ,@vars ,new-var))
117             `(,(car form) ,@vars))))
118 \f
119 ;;;; SETF itself
120
121 ;;; Except for atoms, we always call GET-SETF-EXPANSION, since it has
122 ;;; some non-trivial semantics. But when there is a setf inverse, and
123 ;;; G-S-E uses it, then we return a call to the inverse, rather than
124 ;;; returning a hairy LET form. This is probably important mainly as a
125 ;;; convenience in allowing the use of SETF inverses without the full
126 ;;; interpreter.
127 (defmacro-mundanely setf (&rest args &environment env)
128   #!+sb-doc
129   "Takes pairs of arguments like SETQ. The first is a place and the second
130   is the value that is supposed to go into that place. Returns the last
131   value. The place argument may be any of the access forms for which SETF
132   knows a corresponding setting form."
133   (let ((nargs (length args)))
134     (cond
135      ((= nargs 2)
136       (let ((place (first args))
137             (value-form (second args)))
138         (if (atom place)
139           `(setq ,place ,value-form)
140           (multiple-value-bind (dummies vals newval setter getter)
141               (sb!xc:get-setf-expansion place env)
142             (declare (ignore getter))
143             (let ((inverse (info :setf :inverse (car place))))
144               (if (and inverse (eq inverse (car setter)))
145                 `(,inverse ,@(cdr place) ,value-form)
146                 `(let* (,@(mapcar #'list dummies vals))
147                    (multiple-value-bind ,newval ,value-form
148                      ,setter))))))))
149      ((oddp nargs)
150       (error "odd number of args to SETF"))
151      (t
152       (do ((a args (cddr a))
153            (reversed-setfs nil))
154           ((null a)
155            `(progn ,@(nreverse reversed-setfs)))
156         (push (list 'setf (car a) (cadr a)) reversed-setfs))))))
157 \f
158 ;;;; various SETF-related macros
159
160 (defmacro-mundanely shiftf (&whole form &rest args &environment env)
161   #!+sb-doc
162   "One or more SETF-style place expressions, followed by a single
163    value expression. Evaluates all of the expressions in turn, then
164    assigns the value of each expression to the place on its left,
165    returning the value of the leftmost."
166   (when (< (length args) 2)
167     (error "~S called with too few arguments: ~S" 'shiftf form))
168   (let (let*-bindings mv-bindings setters getters)
169     (dolist (arg (butlast args))
170       (multiple-value-bind (temps subforms store-vars setter getter)
171           (sb!xc:get-setf-expansion arg env)
172         (mapc (lambda (tmp form)
173                 (push `(,tmp ,form) let*-bindings))
174               temps
175               subforms)
176         (push store-vars mv-bindings)
177         (push setter setters)
178         (push getter getters)))
179     ;; Handle the last arg specially here. The getter is just the last
180     ;; arg itself.
181     (push (car (last args)) getters)
182
183     ;; Reverse the collected lists so last bit looks nicer.
184     (setf let*-bindings (nreverse let*-bindings)
185           mv-bindings (nreverse mv-bindings)
186           setters (nreverse setters)
187           getters (nreverse getters))
188
189     (labels ((thunk (mv-bindings getters)
190                (if mv-bindings
191                    `((multiple-value-bind
192                            ,(car mv-bindings)
193                          ,(car getters)
194                        ,@(thunk (cdr mv-bindings) (cdr getters))))
195                    `(,@setters))))
196       `(let ,let*-bindings
197         (multiple-value-bind ,(car mv-bindings)
198             ,(car getters)
199           ,@(thunk mv-bindings (cdr getters))
200           (values ,@(car mv-bindings)))))))
201
202 (defmacro-mundanely push (obj place &environment env)
203   #!+sb-doc
204   "Takes an object and a location holding a list. Conses the object onto
205   the list, returning the modified list. OBJ is evaluated before PLACE."
206   (multiple-value-bind (dummies vals newval setter getter)
207       (get-setf-method place env)
208     (let ((g (gensym)))
209       `(let* ((,g ,obj)
210               ,@(mapcar #'list dummies vals)
211               (,(car newval) (cons ,g ,getter)))
212          ,setter))))
213
214 (defmacro-mundanely pushnew (obj place &rest keys &environment env)
215   #!+sb-doc
216   "Takes an object and a location holding a list. If the object is
217   already in the list, does nothing; otherwise, conses the object onto
218   the list. Returns the modified list. If there is a :TEST keyword, this
219   is used for the comparison."
220   (multiple-value-bind (dummies vals newval setter getter)
221       (get-setf-method place env)
222     (let ((g (gensym)))
223       `(let* ((,g ,obj)
224               ,@(mapcar #'list dummies vals)
225               (,(car newval) (adjoin ,g ,getter ,@keys)))
226          ,setter))))
227
228 (defmacro-mundanely pop (place &environment env)
229   #!+sb-doc
230   "The argument is a location holding a list. Pops one item off the front
231   of the list and returns it."
232   (multiple-value-bind (dummies vals newval setter getter)
233       (get-setf-method place env)
234     (do* ((d dummies (cdr d))
235           (v vals (cdr v))
236           (let-list nil))
237          ((null d)
238           (push (list (car newval) getter) let-list)
239           `(let* ,(nreverse let-list)
240              (prog1 (car ,(car newval))
241                (setq ,(car newval) (cdr ,(car newval)))
242                ,setter)))
243       (push (list (car d) (car v)) let-list))))
244
245 (defmacro-mundanely remf (place indicator &environment env)
246   #!+sb-doc
247   "Place may be any place expression acceptable to SETF, and is expected
248   to hold a property list or (). This list is destructively altered to
249   remove the property specified by the indicator. Returns T if such a
250   property was present, NIL if not."
251   (multiple-value-bind (dummies vals newval setter getter)
252       (get-setf-method place env)
253     (do* ((d dummies (cdr d))
254           (v vals (cdr v))
255           (let-list nil)
256           (ind-temp (gensym))
257           (local1 (gensym))
258           (local2 (gensym)))
259          ((null d)
260           (push (list (car newval) getter) let-list)
261           (push (list ind-temp indicator) let-list)
262           `(let* ,(nreverse let-list)
263              (do ((,local1 ,(car newval) (cddr ,local1))
264                   (,local2 nil ,local1))
265                  ((atom ,local1) nil)
266                (cond ((atom (cdr ,local1))
267                       (error "Odd-length property list in REMF."))
268                      ((eq (car ,local1) ,ind-temp)
269                       (cond (,local2
270                              (rplacd (cdr ,local2) (cddr ,local1))
271                              (return t))
272                             (t (setq ,(car newval) (cddr ,(car newval)))
273                                ,setter
274                                (return t))))))))
275       (push (list (car d) (car v)) let-list))))
276 \f
277 ;;;; DEFINE-MODIFY-MACRO stuff
278
279 (def!macro sb!xc:define-modify-macro (name lambda-list function &optional doc-string)
280   #!+sb-doc
281   "Creates a new read-modify-write macro like PUSH or INCF."
282   (let ((other-args nil)
283         (rest-arg nil)
284         (env (gensym))
285         (reference (gensym)))
286     ;; Parse out the variable names and &REST arg from the lambda list.
287     (do ((ll lambda-list (cdr ll))
288          (arg nil))
289         ((null ll))
290       (setq arg (car ll))
291       (cond ((eq arg '&optional))
292             ((eq arg '&rest)
293              (if (symbolp (cadr ll))
294                (setq rest-arg (cadr ll))
295                (error "Non-symbol &REST argument in definition of ~S." name))
296              (if (null (cddr ll))
297                (return nil)
298                (error "Illegal stuff after &REST argument.")))
299             ((memq arg '(&key &allow-other-keys &aux))
300              (error "~S not allowed in DEFINE-MODIFY-MACRO lambda list." arg))
301             ((symbolp arg)
302              (push arg other-args))
303             ((and (listp arg) (symbolp (car arg)))
304              (push (car arg) other-args))
305             (t (error "Illegal stuff in lambda list."))))
306     (setq other-args (nreverse other-args))
307     `(#-sb-xc-host sb!xc:defmacro
308       #+sb-xc-host defmacro-mundanely
309          ,name (,reference ,@lambda-list &environment ,env)
310        ,doc-string
311        (multiple-value-bind (dummies vals newval setter getter)
312            (get-setf-method ,reference ,env)
313          (do ((d dummies (cdr d))
314               (v vals (cdr v))
315               (let-list nil (cons (list (car d) (car v)) let-list)))
316              ((null d)
317               (push (list (car newval)
318                           ,(if rest-arg
319                              `(list* ',function getter ,@other-args ,rest-arg)
320                              `(list ',function getter ,@other-args)))
321                     let-list)
322               `(let* ,(nreverse let-list)
323                  ,setter)))))))
324
325 (sb!xc:define-modify-macro incf (&optional (delta 1)) +
326   #!+sb-doc
327   "The first argument is some location holding a number. This number is
328   incremented by the second argument, DELTA, which defaults to 1.")
329
330 (sb!xc:define-modify-macro decf (&optional (delta 1)) -
331   #!+sb-doc
332   "The first argument is some location holding a number. This number is
333   decremented by the second argument, DELTA, which defaults to 1.")
334 \f
335 ;;;; DEFSETF
336
337 (eval-when (#-sb-xc :compile-toplevel :load-toplevel :execute)
338   ;;; Assign SETF macro information for NAME, making all appropriate checks.
339   (defun assign-setf-macro (name expander inverse doc)
340     (with-single-package-locked-error
341         (:symbol name "defining a setf-expander for ~A"))
342     (cond ((gethash name sb!c:*setf-assumed-fboundp*)
343            (warn
344             "defining setf macro for ~S when ~S was previously ~
345              treated as a function"
346             name
347             `(setf ,name)))
348           ((not (fboundp `(setf ,name)))
349            ;; All is well, we don't need any warnings.
350            (values))
351           ((not (eq (symbol-package name) (symbol-package 'aref)))
352            (style-warn "defining setf macro for ~S when ~S is fbound"
353                        name `(setf ,name))))
354     (remhash name sb!c:*setf-assumed-fboundp*)
355     ;; FIXME: It's probably possible to join these checks into one form which
356     ;; is appropriate both on the cross-compilation host and on the target.
357     (when (or inverse (info :setf :inverse name))
358       (setf (info :setf :inverse name) inverse))
359     (when (or expander (info :setf :expander name))
360       (setf (info :setf :expander name) expander))
361     (when doc
362       (setf (fdocumentation name 'setf) doc))
363     name))
364
365 (def!macro sb!xc:defsetf (access-fn &rest rest)
366   #!+sb-doc
367   "Associates a SETF update function or macro with the specified access
368   function or macro. The format is complex. See the manual for details."
369   (cond ((not (listp (car rest)))
370          `(eval-when (:load-toplevel :compile-toplevel :execute)
371             (assign-setf-macro ',access-fn
372                                nil
373                                ',(car rest)
374                                 ,(when (and (car rest) (stringp (cadr rest)))
375                                    `',(cadr rest)))))
376         ((and (cdr rest) (listp (cadr rest)))
377          (destructuring-bind
378              (lambda-list (&rest store-variables) &body body)
379              rest
380            (let ((arglist-var (gensym "ARGS-"))
381                  (access-form-var (gensym "ACCESS-FORM-"))
382                  (env-var (gensym "ENVIRONMENT-")))
383              (multiple-value-bind (body local-decs doc)
384                  (parse-defmacro `(,lambda-list ,@store-variables)
385                                  arglist-var body access-fn 'defsetf
386                                  :anonymousp t)
387                `(eval-when (:compile-toplevel :load-toplevel :execute)
388                   (assign-setf-macro
389                    ',access-fn
390                    (lambda (,access-form-var ,env-var)
391                      (declare (ignore ,env-var))
392                      (%defsetf ,access-form-var ,(length store-variables)
393                                (lambda (,arglist-var)
394                                  ,@local-decs
395                                  ,body)))
396                    nil
397                    ',doc))))))
398         (t
399          (error "ill-formed DEFSETF for ~S" access-fn))))
400
401 (defun %defsetf (orig-access-form num-store-vars expander)
402   (declare (type function expander))
403   (let (subforms
404         subform-vars
405         subform-exprs
406         store-vars)
407     (dolist (subform (cdr orig-access-form))
408       (if (constantp subform)
409         (push subform subforms)
410         (let ((var (gensym)))
411           (push var subforms)
412           (push var subform-vars)
413           (push subform subform-exprs))))
414     (dotimes (i num-store-vars)
415       (push (gensym) store-vars))
416     (let ((r-subforms (nreverse subforms))
417           (r-subform-vars (nreverse subform-vars))
418           (r-subform-exprs (nreverse subform-exprs))
419           (r-store-vars (nreverse store-vars)))
420       (values r-subform-vars
421               r-subform-exprs
422               r-store-vars
423               (funcall expander (cons r-subforms r-store-vars))
424               `(,(car orig-access-form) ,@r-subforms)))))
425 \f
426 ;;;; DEFMACRO DEFINE-SETF-EXPANDER and various DEFINE-SETF-EXPANDERs
427
428 ;;; DEFINE-SETF-EXPANDER is a lot like DEFMACRO.
429 (def!macro sb!xc:define-setf-expander (access-fn lambda-list &body body)
430   #!+sb-doc
431   "Syntax like DEFMACRO, but creates a Setf-Method generator. The body
432   must be a form that returns the five magical values."
433   (unless (symbolp access-fn)
434     (error "DEFINE-SETF-EXPANDER access-function name ~S is not a symbol."
435            access-fn))
436   (with-unique-names (whole environment)
437     (multiple-value-bind (body local-decs doc)
438         (parse-defmacro lambda-list whole body access-fn
439                         'sb!xc:define-setf-expander
440                         :environment environment)
441       `(eval-when (:compile-toplevel :load-toplevel :execute)
442          (assign-setf-macro ',access-fn
443                             (lambda (,whole ,environment)
444                               ,@local-decs
445                               ,body)
446                             nil
447                             ',doc)))))
448
449 (sb!xc:define-setf-expander getf (place prop
450                                   &optional default
451                                   &environment env)
452   (declare (type sb!c::lexenv env))
453   (multiple-value-bind (temps values stores set get)
454       (get-setf-method place env)
455     (let ((newval (gensym))
456           (ptemp (gensym))
457           (def-temp (if default (gensym))))
458       (values `(,@temps ,ptemp ,@(if default `(,def-temp)))
459               `(,@values ,prop ,@(if default `(,default)))
460               `(,newval)
461               `(let ((,(car stores) (%putf ,get ,ptemp ,newval)))
462                  ,set
463                  ,newval)
464               `(getf ,get ,ptemp ,@(if default `(,def-temp)))))))
465
466 (sb!xc:define-setf-expander get (symbol prop &optional default)
467   (let ((symbol-temp (gensym))
468         (prop-temp (gensym))
469         (def-temp (gensym))
470         (newval (gensym)))
471     (values `(,symbol-temp ,prop-temp ,@(if default `(,def-temp)))
472             `(,symbol ,prop ,@(if default `(,default)))
473             (list newval)
474             `(%put ,symbol-temp ,prop-temp ,newval)
475             `(get ,symbol-temp ,prop-temp ,@(if default `(,def-temp))))))
476
477 (sb!xc:define-setf-expander gethash (key hashtable &optional default)
478   (let ((key-temp (gensym))
479         (hashtable-temp (gensym))
480         (default-temp (gensym))
481         (new-value-temp (gensym)))
482     (values
483      `(,key-temp ,hashtable-temp ,@(if default `(,default-temp)))
484      `(,key ,hashtable ,@(if default `(,default)))
485      `(,new-value-temp)
486      `(%puthash ,key-temp ,hashtable-temp ,new-value-temp)
487      `(gethash ,key-temp ,hashtable-temp ,@(if default `(,default-temp))))))
488
489 (sb!xc:define-setf-expander logbitp (index int &environment env)
490   (declare (type sb!c::lexenv env))
491   (multiple-value-bind (temps vals stores store-form access-form)
492       (get-setf-method int env)
493     (let ((ind (gensym))
494           (store (gensym))
495           (stemp (first stores)))
496       (values `(,ind ,@temps)
497               `(,index
498                 ,@vals)
499               (list store)
500               `(let ((,stemp
501                       (dpb (if ,store 1 0) (byte 1 ,ind) ,access-form)))
502                  ,store-form
503                  ,store)
504               `(logbitp ,ind ,access-form)))))
505
506 ;;; CMU CL had a comment here that:
507 ;;;   Evil hack invented by the gnomes of Vassar Street (though not as evil as
508 ;;;   it used to be.)  The function arg must be constant, and is converted to
509 ;;;   an APPLY of the SETF function, which ought to exist.
510 ;;;
511 ;;; It may not be clear (wasn't to me..) that this is a standard thing, but See
512 ;;; "5.1.2.5 APPLY Forms as Places" in the ANSI spec. I haven't actually
513 ;;; verified that this code has any correspondence to that code, but at least
514 ;;; ANSI has some place for SETF APPLY. -- WHN 19990604
515 (sb!xc:define-setf-expander apply (functionoid &rest args)
516   (unless (and (listp functionoid)
517                (= (length functionoid) 2)
518                (eq (first functionoid) 'function)
519                (symbolp (second functionoid)))
520     (error "SETF of APPLY is only defined for function args like #'SYMBOL."))
521   (let ((function (second functionoid))
522         (new-var (gensym))
523         (vars (make-gensym-list (length args))))
524     (values vars args (list new-var)
525             `(apply #'(setf ,function) ,new-var ,@vars)
526             `(apply #',function ,@vars))))
527
528 ;;; Special-case a BYTE bytespec so that the compiler can recognize it.
529 (sb!xc:define-setf-expander ldb (bytespec place &environment env)
530   #!+sb-doc
531   "The first argument is a byte specifier. The second is any place form
532   acceptable to SETF. Replace the specified byte of the number in this
533   place with bits from the low-order end of the new value."
534   (declare (type sb!c::lexenv env))
535   (multiple-value-bind (dummies vals newval setter getter)
536       (get-setf-method place env)
537     (if (and (consp bytespec) (eq (car bytespec) 'byte))
538         (let ((n-size (gensym))
539               (n-pos (gensym))
540               (n-new (gensym)))
541           (values (list* n-size n-pos dummies)
542                   (list* (second bytespec) (third bytespec) vals)
543                   (list n-new)
544                   `(let ((,(car newval) (dpb ,n-new (byte ,n-size ,n-pos)
545                                              ,getter)))
546                      ,setter
547                      ,n-new)
548                   `(ldb (byte ,n-size ,n-pos) ,getter)))
549         (let ((btemp (gensym))
550               (gnuval (gensym)))
551           (values (cons btemp dummies)
552                   (cons bytespec vals)
553                   (list gnuval)
554                   `(let ((,(car newval) (dpb ,gnuval ,btemp ,getter)))
555                      ,setter
556                      ,gnuval)
557                   `(ldb ,btemp ,getter))))))
558
559 (sb!xc:define-setf-expander mask-field (bytespec place &environment env)
560   #!+sb-doc
561   "The first argument is a byte specifier. The second is any place form
562   acceptable to SETF. Replaces the specified byte of the number in this place
563   with bits from the corresponding position in the new value."
564   (declare (type sb!c::lexenv env))
565   (multiple-value-bind (dummies vals newval setter getter)
566       (get-setf-method place env)
567     (let ((btemp (gensym))
568           (gnuval (gensym)))
569       (values (cons btemp dummies)
570               (cons bytespec vals)
571               (list gnuval)
572               `(let ((,(car newval) (deposit-field ,gnuval ,btemp ,getter)))
573                  ,setter
574                  ,gnuval)
575               `(mask-field ,btemp ,getter)))))
576
577 (sb!xc:define-setf-expander the (type place &environment env)
578   (declare (type sb!c::lexenv env))
579   (multiple-value-bind (dummies vals newval setter getter)
580       (get-setf-method place env)
581     (values dummies
582               vals
583               newval
584               (subst `(the ,type ,(car newval)) (car newval) setter)
585               `(the ,type ,getter))))