[189dd8]: src / code / symbol.lisp Maximize Restore History

Download this file

symbol.lisp    487 lines (433 with data), 20.2 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
;;;; code to manipulate symbols (but not packages, which are handled
;;;; elsewhere)
;;;;
;;;; Many of these definitions are trivial interpreter entries to
;;;; functions open-coded by the compiler.
;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; This software is derived from the CMU CL system, which was
;;;; written at Carnegie Mellon University and released into the
;;;; public domain. The software is in the public domain and is
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.
(in-package "SB!IMPL")
(declaim (maybe-inline get get3 %put getf remprop %putf get-properties keywordp))
(defun symbol-value (symbol)
#!+sb-doc
"Return SYMBOL's current bound value."
(declare (optimize (safety 1)))
(symbol-value symbol))
#-sb-xc-host
(define-compiler-macro symbol-value (&whole form symbol &environment env)
(when (sb!xc:constantp symbol env)
(let ((name (constant-form-value symbol env)))
(when (symbolp name)
(check-deprecated-variable name))))
form)
(defun boundp (symbol)
#!+sb-doc
"Return non-NIL if SYMBOL is bound to a value."
(boundp symbol))
(defun set (symbol new-value)
#!+sb-doc
"Set SYMBOL's value cell to NEW-VALUE."
(declare (type symbol symbol))
(about-to-modify-symbol-value symbol 'set new-value)
(%set-symbol-value symbol new-value))
(defun %set-symbol-value (symbol new-value)
(%set-symbol-value symbol new-value))
(defun symbol-global-value (symbol)
#!+sb-doc
"Return the SYMBOL's current global value. Identical to SYMBOL-VALUE,
in single-threaded builds: in multithreaded builds bound values are
distinct from the global value. Can also be SETF."
(declare (optimize (safety 1)))
(symbol-global-value symbol))
(defun set-symbol-global-value (symbol new-value)
(about-to-modify-symbol-value symbol 'set new-value)
(%set-symbol-global-value symbol new-value))
(declaim (inline %makunbound))
(defun %makunbound (symbol)
(%set-symbol-value symbol (%primitive sb!c:make-unbound-marker)))
(defun makunbound (symbol)
#!+sb-doc
"Make SYMBOL unbound, removing any value it may currently have."
(with-single-package-locked-error (:symbol symbol "unbinding the symbol ~A")
;; :EVENTUALLY is allowed for :always-bound here, as it has no bearing
(when (eq (info :variable :always-bound symbol) :always-bound)
(error "Can't make ~A variable unbound: ~S" 'always-bound symbol))
(about-to-modify-symbol-value symbol 'makunbound)
(%makunbound symbol)
symbol))
;;; Return the built-in hash value for SYMBOL.
(defun symbol-hash (symbol)
(symbol-hash symbol))
(defun symbol-function (symbol)
#!+sb-doc
"Return SYMBOL's current function definition. Settable with SETF."
(!coerce-name-to-fun symbol-fdefn symbol))
(defun (setf symbol-function) (new-value symbol)
(declare (type symbol symbol) (type function new-value))
(with-single-package-locked-error
(:symbol symbol "setting the symbol-function of ~A")
(setf (%coerce-name-to-fun symbol) new-value)))
;;; Accessors for the dual-purpose info/plist slot
;; A symbol's INFO slot is always in one of three states:
;; 1. NIL ; the initial state
;; 2. #(data ....) ; globaldb used the slot
;; 3. (PLIST . NIL) or (PLIST . #(data ...)) ; plist was touched,
;; and also possibly globaldb used the slot
;;
;; State 1 transitions to state 2 by assigning globaldb data,
;; or to state 3 via ({SETF|CAS} SYMBOL-PLIST).
;; (SETF INFO) by itself will never cause 1 -> 3 transition.
;; State 2 transitions to state 3 via ({SETF|CAS} SYMBOL-PLIST).
;; There are *no* other permissible state transitions.
(defun symbol-info (symbol)
(symbol-info symbol))
;; An "interpreter stub" for an operation that is only implemented for
;; the benefit of platforms without compare-and-swap-vops.
(defun (setf symbol-info) (new-info symbol)
(setf (symbol-info symbol) new-info))
;; Atomically update SYMBOL's info/plist slot to contain a new info vector.
;; The vector is computed by calling UPDATE-FN on the old vector,
;; repeatedly as necessary, until no conflict happens with other updaters.
;; The function may choose to abort the update by returning NIL.
(defun update-symbol-info (symbol update-fn)
(declare (symbol symbol)
(type (function (t) t) update-fn))
(prog ((info-holder (symbol-info symbol))
(current-vect))
outer-restart
;; Do not use SYMBOL-INFO-VECTOR - this must not perform a slot read again.
(setq current-vect (if (listp info-holder) (cdr info-holder) info-holder))
inner-restart
;; KLUDGE: The "#." on +nil-packed-infos+ is due to slightly crippled
;; fops in genesis's fasload. Anonymizing the constant works around the
;; issue, at the expense of an extra copy of the empty info vector.
(let ((new-vect (funcall update-fn
(or current-vect #.sb!c::+nil-packed-infos+))))
(unless (simple-vector-p new-vect)
(aver (null new-vect))
(return)) ; nothing to do
(if (consp info-holder) ; State 3: exchange the CDR
(let ((old (%compare-and-swap-cdr info-holder current-vect new-vect)))
(when (eq old current-vect) (return t)) ; win
(setq current-vect old) ; Don't touch holder- it's still a cons
(go inner-restart)))
;; State 1 or 2: info-holder is NIL or a vector.
;; Exchange the contents of the info slot. Type-inference derives
;; SIMPLE-VECTOR-P on the args to CAS, so no extra checking.
(let ((old (%compare-and-swap-symbol-info symbol info-holder new-vect)))
(when (eq old info-holder) (return t)) ; win
;; Check whether we're in state 2 or 3 now.
;; Impossible to be in state 1: nobody ever puts NIL in the slot.
;; Up above, we bailed out if the update-fn returned NIL.
(setq info-holder old)
(go outer-restart)))))
(eval-when (:compile-toplevel)
;; If we're in state 1 or state 3, we can take (CAR (SYMBOL-INFO S))
;; to get the property list. If we're in state 2, this same access
;; gets the fixnum which is the VECTOR-LENGTH of the info vector.
;; So all we have to do is turn any fixnum to NIL, and we have a plist.
;; Ensure that this pun stays working.
(assert (= (- (* sb!vm:n-word-bytes sb!vm:cons-car-slot)
sb!vm:list-pointer-lowtag)
(- (* sb!vm:n-word-bytes sb!vm:vector-length-slot)
sb!vm:other-pointer-lowtag))))
(defun symbol-plist (symbol)
#!+sb-doc
"Return SYMBOL's property list."
#!+symbol-info-vops
(symbol-plist symbol) ; VOP translates it
#!-symbol-info-vops
(let ((list (car (truly-the list (symbol-info symbol))))) ; a white lie
;; Just ensure the result is not a fixnum, and we're done.
(if (fixnump list) nil list)))
(declaim (ftype (sfunction (symbol t) cons) %ensure-plist-holder)
(inline %ensure-plist-holder))
;; When a plist update (setf or cas) is first performed on a symbol,
;; a one-time allocation of an extra cons is done which creates two
;; "slots" from one: a slot for the info-vector and a slot for the plist.
;; This avoids complications in the implementation of the user-facing
;; (CAS SYMBOL-PLIST) function, which should not have to be aware of
;; competition from globaldb mutators even if no other threads attempt
;; to manipulate the plist per se.
;; Given a SYMBOL and its current INFO of type (OR LIST SIMPLE-VECTOR)
;; ensure that SYMBOL's current info is a cons, and return that.
;; If racing with multiple threads, at most one thread will install the cons.
(defun %ensure-plist-holder (symbol info)
;; Invoked only when SYMBOL is known to be a symbol.
(declare (optimize (safety 0)))
(if (consp info) ; it's fine to call this with a cell already installed
info ; all done
(let (newcell)
;; The pointer from the new cons to the old info must be persisted
;; to memory before the symbol's info slot points to the cons.
;; [x86oid doesn't need the barrier, others might]
(sb!thread:barrier (:write)
(setq newcell (cons nil info)))
(loop (let ((old (%compare-and-swap-symbol-info symbol info newcell)))
(cond ((eq old info) (return newcell)) ; win
((consp old) (return old))) ; somebody else made a cons!
(setq info old)
(sb!thread:barrier (:write) ; Retry using same newcell
(rplacd newcell info)))))))
(declaim (inline %compare-and-swap-symbol-plist
%set-symbol-plist))
(defun %compare-and-swap-symbol-plist (symbol old new)
;; This is the entry point into which (CAS SYMBOL-PLIST) is transformed.
;; If SYMBOL's info cell is a cons, we can do (CAS CAR). Otherwise punt.
(declare (symbol symbol) (list old new))
(let ((cell (symbol-info symbol)))
(if (consp cell)
(%compare-and-swap-car cell old new)
(%%compare-and-swap-symbol-plist symbol old new))))
(defun %%compare-and-swap-symbol-plist (symbol old new)
;; This is just the second half of a partially-inline function, to avoid
;; code bloat in the exceptional case. Type assertions should have been
;; done - or not, per policy - by the caller of %COMPARE-AND-SWAP-SYMBOL-PLIST
;; so now use TRULY-THE to avoid further type checking.
(%compare-and-swap-car (%ensure-plist-holder (truly-the symbol symbol)
(symbol-info symbol))
old new))
(defun %set-symbol-plist (symbol new-value)
;; This is the entry point into which (SETF SYMBOL-PLIST) is transformed.
;; If SYMBOL's info cell is a cons, we can do (SETF CAR). Otherwise punt.
(declare (symbol symbol) (list new-value))
(let ((cell (symbol-info symbol)))
(if (consp cell)
(setf (car cell) new-value)
(%%set-symbol-plist symbol new-value))))
(defun %%set-symbol-plist (symbol new-value)
;; Same considerations as for %%COMPARE-AND-SWAP-SYMBOL-PLIST,
;; with a slight efficiency hack: if the symbol has no plist holder cell
;; and the NEW-VALUE is NIL, try to avoid creating a holder cell.
;; Yet we must write something, because omitting a memory operation
;; could have a subtle effect in the presence of multi-threading.
(let ((info (symbol-info (truly-the symbol symbol))))
(when (and (not new-value) (atom info)) ; try to treat this as a no-op
(let ((old (%compare-and-swap-symbol-info symbol info info)))
(if (eq old info) ; good enough
(return-from %%set-symbol-plist new-value) ; = nil
(setq info old))))
(setf (car (%ensure-plist-holder symbol info)) new-value)))
;;; End of Info/Plist slot manipulation
(defun symbol-name (symbol)
#!+sb-doc
"Return SYMBOL's name as a string."
(symbol-name symbol))
(defun symbol-package (symbol)
#!+sb-doc
"Return the package SYMBOL was interned in, or NIL if none."
(symbol-package symbol))
(defun %set-symbol-package (symbol package)
(declare (type symbol symbol))
(%set-symbol-package symbol package))
(defun make-symbol (string)
#!+sb-doc
"Make and return a new symbol with the STRING as its print name."
(declare (type string string))
(%make-symbol (if (simple-string-p string)
string
(subseq string 0))))
(defun get (symbol indicator &optional (default nil))
#!+sb-doc
"Look on the property list of SYMBOL for the specified INDICATOR. If this
is found, return the associated value, else return DEFAULT."
(get3 symbol indicator default))
(defun get3 (symbol indicator default)
(let (cdr-pl)
(do ((pl (symbol-plist symbol) (cdr cdr-pl)))
((atom pl) default)
(setq cdr-pl (cdr pl))
(cond ((atom cdr-pl)
(error "~S has an odd number of items in its property list."
symbol))
((eq (car pl) indicator)
(return (car cdr-pl)))))))
(defun %put (symbol indicator value)
#!+sb-doc
"The VALUE is added as a property of SYMBOL under the specified INDICATOR.
Returns VALUE."
(do ((pl (symbol-plist symbol) (cddr pl)))
((endp pl)
(setf (symbol-plist symbol)
(list* indicator value (symbol-plist symbol)))
value)
(cond ((endp (cdr pl))
(error "~S has an odd number of items in its property list."
symbol))
((eq (car pl) indicator)
(rplaca (cdr pl) value)
(return value)))))
(defun remprop (symbol indicator)
#!+sb-doc
"Look on property list of SYMBOL for property with specified
INDICATOR. If found, splice this indicator and its value out of
the plist, and return the tail of the original list starting with
INDICATOR. If not found, return () with no side effects.
NOTE: The ANSI specification requires REMPROP to return true (not false)
or false (the symbol NIL). Portable code should not rely on any other value."
(do ((pl (symbol-plist symbol) (cddr pl))
(prev nil pl))
((atom pl) nil)
(cond ((atom (cdr pl))
(error "~S has an odd number of items in its property list."
symbol))
((eq (car pl) indicator)
(cond (prev (rplacd (cdr prev) (cddr pl)))
(t
(setf (symbol-plist symbol) (cddr pl))))
(return pl)))))
(defun getf (place indicator &optional (default ()))
#!+sb-doc
"Search the property list stored in PLACE for an indicator EQ to INDICATOR.
If one is found, return the corresponding value, else return DEFAULT."
(do ((plist place (cddr plist)))
((null plist) default)
(cond ((atom (cdr plist))
(error 'simple-type-error
:format-control "malformed property list: ~S."
:format-arguments (list place)
:datum (cdr plist)
:expected-type 'cons))
((eq (car plist) indicator)
(return (cadr plist))))))
(defun %putf (place property new-value)
(declare (type list place))
(do ((plist place (cddr plist)))
((endp plist) (list* property new-value place))
(declare (type list plist))
(when (eq (car plist) property)
(setf (cadr plist) new-value)
(return place))))
(defun get-properties (place indicator-list)
#!+sb-doc
"Like GETF, except that INDICATOR-LIST is a list of indicators which will
be looked for in the property list stored in PLACE. Three values are
returned, see manual for details."
(do ((plist place (cddr plist)))
((null plist) (values nil nil nil))
(cond ((atom (cdr plist))
(error 'simple-type-error
:format-control "malformed property list: ~S."
:format-arguments (list place)
:datum (cdr plist)
:expected-type 'cons))
((memq (car plist) indicator-list)
(return (values (car plist) (cadr plist) plist))))))
(defun copy-symbol (symbol &optional (copy-props nil) &aux new-symbol)
#!+sb-doc
"Make and return a new uninterned symbol with the same print name
as SYMBOL. If COPY-PROPS is false, the new symbol is neither bound
nor fbound and has no properties, else it has a copy of SYMBOL's
function, value and property list."
(declare (type symbol symbol))
(setq new-symbol (make-symbol (symbol-name symbol)))
(when copy-props
(%set-symbol-value new-symbol
(%primitive sb!c:fast-symbol-value symbol))
(setf (symbol-plist new-symbol)
(copy-list (symbol-plist symbol)))
(when (fboundp symbol)
(setf (symbol-function new-symbol) (symbol-function symbol))))
new-symbol)
;;; FIXME: This declaration should be redundant.
(declaim (special *keyword-package*))
(defun keywordp (object)
#!+sb-doc
"Return true if Object is a symbol in the \"KEYWORD\" package."
(and (symbolp object)
(eq (symbol-package object) *keyword-package*)))
;;;; GENSYM and friends
(defun %make-symbol-name (prefix counter)
(with-output-to-string (s)
(write-string prefix s)
(%output-integer-in-base counter 10 s)))
(defvar *gensym-counter* 0
#!+sb-doc
"counter for generating unique GENSYM symbols")
(declaim (type unsigned-byte *gensym-counter*))
(defun gensym (&optional (thing "G"))
#!+sb-doc
"Creates a new uninterned symbol whose name is a prefix string (defaults
to \"G\"), followed by a decimal number. Thing, when supplied, will
alter the prefix if it is a string, or be used for the decimal number
if it is a number, of this symbol. The default value of the number is
the current value of *gensym-counter* which is incremented each time
it is used."
(let ((old *gensym-counter*))
(unless (numberp thing)
(let ((new (etypecase old
(index (1+ old))
(unsigned-byte (1+ old)))))
(declare (optimize (speed 3) (safety 0) (inhibit-warnings 3)))
(setq *gensym-counter* new)))
(multiple-value-bind (prefix int)
(etypecase thing
(simple-string (values thing old))
(unsigned-byte (values "G" thing))
(string (values (coerce thing 'simple-string) old)))
(declare (simple-string prefix))
(make-symbol (%make-symbol-name prefix int)))))
(defvar *gentemp-counter* 0)
(declaim (type unsigned-byte *gentemp-counter*))
(defun gentemp (&optional (prefix "T") (package (sane-package)))
#!+sb-doc
"Creates a new symbol interned in package PACKAGE with the given PREFIX."
(declare (type string prefix))
(loop for name = (%make-symbol-name prefix (incf *gentemp-counter*))
while (nth-value 1 (find-symbol name package))
finally (return (values (intern name package)))))
;;; This function is to be called just before a change which would affect the
;;; symbol value. We don't absolutely have to call this function before such
;;; changes, since such changes to constants are given as undefined behavior,
;;; it's nice to do so. To circumvent this you need code like this:
;;;
;;; (defvar foo)
;;; (defun set-foo (x) (setq foo x))
;;; (defconstant foo 42)
;;; (set-foo 13)
;;; foo => 13, (constantp 'foo) => t
;;;
;;; ...in which case you frankly deserve to lose.
(defun about-to-modify-symbol-value (symbol action &optional (new-value nil valuep) bind)
(declare (symbol symbol))
(flet ((describe-action ()
(ecase action
(set "set SYMBOL-VALUE of ~S")
(progv "bind ~S")
(compare-and-swap "compare-and-swap SYMBOL-VALUE of ~S")
(defconstant "define ~S as a constant")
(makunbound "make ~S unbound"))))
(let ((kind (info :variable :kind symbol)))
(multiple-value-bind (what continue)
(cond ((eq :constant kind)
(cond ((eq symbol t)
(values "Veritas aeterna. (can't ~@?)" nil))
((eq symbol nil)
(values "Nihil ex nihil. (can't ~@?)" nil))
((keywordp symbol)
(values "Can't ~@?." nil))
(t
(values "Constant modification: attempt to ~@?." t))))
((and bind (eq :global kind))
(values "Can't ~@? (global variable)." nil)))
(when what
(if continue
(cerror "Modify the constant." what (describe-action) symbol)
(error what (describe-action) symbol)))
(when valuep
;; :VARIABLE :TYPE is in the db only if it is declared, so no need to
;; check.
(let ((type (info :variable :type symbol)))
(unless (sb!kernel::%%typep new-value type nil)
(let ((spec (type-specifier type)))
(error 'simple-type-error
:format-control "~@<Cannot ~@? to ~S, not of type ~S.~:@>"
:format-arguments (list (describe-action) symbol new-value spec)
:datum new-value
:expected-type spec))))))))
(values))