| blob | 97c25be1747e461b691993f9313571db9fc7cd57 |
1 ;;;; miscellaneous system hacking macros
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
14 ;;;; these are initialized in cold init
19 ;;; When the dynamic usage increases beyond this amount, the system
20 ;;; notes that a garbage collection needs to occur by setting
21 ;;; *GC-PENDING* to T. It starts out as NIL meaning nobody has figured
22 ;;; out what it should be yet.
25 #!+sb-thread
28 ;;; This one is initialized by the runtime, at thread creation. On
29 ;;; non-x86oid gencgc targets, this is a per-thread list of objects
30 ;;; which must not be moved during GC. It is frobbed by the code for
31 ;;; with-pinned-objects in src/compiler/target/macros.lisp.
36 #!+sb-doc
37 "Executes the forms in the body without doing a garbage collection. It
38 inhibits both automatically and explicitly triggered collections. Finally,
39 upon leaving the BODY if gc is not inhibited it runs the pending gc.
40 Similarly, if gc is triggered in another thread then it waits until gc is
41 enabled in this thread.
43 Implies SB-SYS:WITHOUT-INTERRUPTS for BODY, and causes any nested
44 SB-SYS:WITH-INTERRUPTS to signal a warning during execution of the BODY.
46 Should be used with great care, and not at all in multithreaded application
47 code: Any locks that are ever acquired while GC is inhibited need to be always
48 held with GC inhibited to prevent deadlocks: if T1 holds the lock and is
49 stopped for GC while T2 is waiting for the lock inside WITHOUT-GCING the
50 system will be deadlocked. Since SBCL does not currently document its internal
51 locks, application code can never be certain that this invariant is
52 maintained."
58 ;; We need to disable interrupts before disabling GC, so
59 ;; that signal handlers using locks don't accidentally try
60 ;; to grab them with GC inhibited.
67 ;; This is not racy becuase maybe_defer_handler
68 ;; defers signals if *GC-INHIBIT* is NIL but there
69 ;; is a pending gc or stop-for-gc.
74 \f
75 ;;; EOF-OR-LOSE is a useful macro that handles EOF.
81 ;;; These macros handle the special cases of T and NIL for input and
82 ;;; output streams.
83 ;;; It is unfortunate that the names connote synonym-streams being involved.
84 ;;; Perhaps {IN,OUT}-STREAM-FROM-DESIGNATOR would have been better.
85 ;;; And shouldn't the high-security feature check that if either NIL or T
86 ;;; is given, the designated stream has the right directionality?
87 ;;; Nothing prevents *TERMINAL-IO* from being bound to an output-only stream.
88 ;;;
89 ;;; FIXME: Shouldn't these be functions instead of macros?
96 #!+high-security
104 ;; As noted above, this code is a tad wasteful for probably not a huge
105 ;; performance gain. On the other hand, where STREAM is known to be of type
106 ;; STREAM, it produces shorter code. But we could shorten the general case:
107 #|
114 |#
121 #!+high-security
130 ;;; WITH-mumble-STREAM calls the function in the given SLOT of the
131 ;;; STREAM with the ARGS for ANSI-STREAMs, or the FUNCTION with the
132 ;;; ARGS for FUNDAMENTAL-STREAMs.
157 \f
158 ;;;; These are hacks to make the reader win.
160 ;;; This macro sets up some local vars for use by the
161 ;;; FAST-READ-CHAR macro within the enclosed lexical scope. The stream
162 ;;; is assumed to be a ANSI-STREAM.
163 ;;;
164 ;;; KLUDGE: Some functions (e.g. ANSI-STREAM-READ-LINE) use these variables
165 ;;; directly, instead of indirecting through FAST-READ-CHAR.
166 ;;; When ANSI-STREAM-INPUT-CHAR-POS is non-null, we take care to update it,
167 ;;; but not for each character of input.
177 ;;; This macro must be called after one is done with FAST-READ-CHAR
178 ;;; inside its scope to decache the ANSI-STREAM-IN-INDEX.
179 ;;; To keep the amount of code injected by FAST-READ-CHAR as small as possible,
180 ;;; we avoid bumping the absolute stream position counter at each character.
181 ;;; When finished looping, one extra function call takes care of that.
182 ;;; If buffer refills occurred within FAST-READ-CHAR, the refill logic
183 ;;; similarly scans the cin-buffer before placing anything new into it.
190 ;;; a macro with the same calling convention as READ-CHAR, to be used
191 ;;; within the scope of a PREPARE-FOR-FAST-READ-CHAR.
192 ;;; If EOF-ERROR-P is statically T (not any random expression evaluating
193 ;;; to T) then wrap the whole thing in (TRULY-THE CHARACTER ...)
194 ;;; because it's either going to yield a character or signal EOF.
208 index-or-nil))))
211 %frc-index%))
216 ;; use an EQL specifier only if the const is EQL-comparable
220 result))))
222 ;;;; And these for the fasloader...
224 ;;; Just like PREPARE-FOR-FAST-READ-CHAR except that we get the BIN
225 ;;; method. The stream is assumed to be a ANSI-STREAM.
226 ;;;
227 ;;; FIXME: Refactor PREPARE-FOR-FAST-READ-CHAR into similar shape.
243 ;; KLUDGE: For some reason I haven't tracked down
244 ;; this makes a difference even in given the TRULY-THE.
264 ;; This is an internal-use-only macro.
268 ;; If the &REST arg never needs to be reified, this is slightly quicker
269 ;; than using a DX list.