always NIL for special variables, although arguably it should be T
when there is a lexically apparent binding for the special variable.
-The third value is an alist describind the declarations that apply to
+The third value is an alist describing the declarations that apply to
the function NAME. Standard declaration specifiers that may appear in
CARS of the alist include:
(defun parse-macro (name lambda-list body &optional env)
"Process a macro definition of the kind that might appear in a DEFMACRO form
into a lambda expression of two variables: a form and an environment. The
-lambda edxpression will parse its form argument, binding the variables in
-LAMBDA-LIST appropriately, and then excute BODY with those bindings in
+lambda expression will parse its form argument, binding the variables in
+LAMBDA-LIST appropriately, and then execute BODY with those bindings in
effect."
(declare (ignore env))
(with-unique-names (whole environment)
(defstruct (gate (:constructor %make-gate)
(:copier nil)
(:predicate gatep))
- "GATE type. Gates are syncronization constructs suitable for making
+ "GATE type. Gates are synchronization constructs suitable for making
multiple threads wait for single event before proceeding.
Use WAIT-ON-GATE to wait for a gate to open, OPEN-GATE to open one,
(setf (documentation 'queuep 'function)
"Returns true if argument is a QUEUE, NIL otherwise."
(documentation 'queue-name 'function)
- "Name of a QUEUE. Can be assingned to using SETF. Queue names
+ "Name of a QUEUE. Can be assignned to using SETF. Queue names
can be arbitrary printable objects, and need not be unique.")
(defun make-queue (&key name initial-contents)
For :HEAP objects the secondary value is a plist:
:SPACE
- Inficates the heap segment the object is allocated in.
+ Indicates the heap segment the object is allocated in.
:GENERATION
Is the current generation of the object: 0 for nursery, 6 for pseudo-static
:documentation "Initial working directory.")
(shell :initarg :shell :accessor passwd-shell
:documentation "Program to use as shell."))
- (:documentation "Instances of this class represent entries in
- the system's user database."))
+ (:documentation
+ "Instances of this class represent entries in the system's user database."))
;;; group database
#-win32
(mtime :initarg :mtime :reader stat-mtime
:documentation "Time of last data modification.")
(ctime :initarg :ctime :reader stat-ctime
- :documentation "Time of last status change"))
- (:documentation "Instances of this class represent Posix file
- metadata."))
+ :documentation "Time of last status change."))
+ (:documentation "Instances of this class represent POSIX file metadata."))
(defmacro define-stat-call (name arg designator-fun type)
;; FIXME: this isn't the documented way of doing this, surely?
:documentation "Local modes.")
(cc :initarg :cc :accessor sb-posix:termios-cc :array-length nccs
:documentation "Control characters."))
- (:documentation "Instances of this class represent I/O
- characteristics of the terminal."))
+ (:documentation
+ "Instances of this class represent I/O characteristics of the terminal."))
#-win32
(progn
loop around the BODY until a sufficient number of samples has been collected.
Returns the values from the last evaluation of BODY.
-In multi-threaded operation, only the thread in which WITH-PROFILING was
+In multithreaded operation, only the thread in which WITH-PROFILING was
evaluated will be profiled by default. If you want to profile multiple
threads, invoke the profiler with START-PROFILING.
of this. In this case using :MODE :TIME is likely to work better.
:LOOP <bool>
- If false (the default), evaluete BODY only once. If true repeatedly
+ If false (the default), evaluate BODY only once. If true repeatedly
evaluate BODY."
(declare (type report-type report))
(check-type loop boolean)
:doc
"private: miscellaneous unsupported extensions to the ANSI spec. Much of
the stuff in here originated in CMU CL's EXTENSIONS package and is retained,
-possibly temporariliy, because it might be used internally."
+possibly temporarily, because it might be used internally."
:use ("CL" "SB!ALIEN" "SB!GRAY" "SB!FASL" "SB!SYS")
:export (;; lambda list keyword extensions
"&MORE"
"THREAD-ERROR"
"THREAD-ERROR-THREAD"
"THREAD-ALIVE-P"
- "THREAD-EMPHEMERAL-P"
+ "THREAD-EPHEMERAL-P"
"THREAD-NAME"
"THREAD-YIELD"
"FOREIGN-THREAD"
(defun row-major-aref (array index)
#!+sb-doc
- "Return the element of array corressponding to the row-major index. This is
- SETF'able."
+ "Return the element of array corresponding to the row-major index. This is
+ SETFable."
(declare (optimize (safety 1)))
(row-major-aref array index))
(defun svref (simple-vector index)
#!+sb-doc
- "Return the INDEX'th element of the given Simple-Vector."
+ "Return the INDEXth element of the given Simple-Vector."
(declare (optimize (safety 1)))
(aref simple-vector index))
;;; should probably be based on the VECTOR-PUSH-EXTEND code (which is
;;; new ca. sbcl-0.7.0) rather than the VECTOR-PUSH code (which dates
;;; back to CMU CL).
-(defun vector-push (new-el array)
+(defun vector-push (new-element array)
#!+sb-doc
"Attempt to set the element of ARRAY designated by its fill pointer
- to NEW-EL, and increment the fill pointer by one. If the fill pointer is
+ to NEW-ELEMENT, and increment the fill pointer by one. If the fill pointer is
too large, NIL is returned, otherwise the index of the pushed element is
returned."
(let ((fill-pointer (fill-pointer array)))
nil)
(t
(locally (declare (optimize (safety 0)))
- (setf (aref array fill-pointer) new-el))
+ (setf (aref array fill-pointer) new-element))
(setf (%array-fill-pointer array) (1+ fill-pointer))
fill-pointer))))
(def!macro cas (place old new &environment env)
"Synonym for COMPARE-AND-SWAP.
-Addtionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be also used to
+Additionally DEFUN, DEFGENERIC, DEFMETHOD, FLET, and LABELS can be also used to
define CAS-functions analogously to SETF-functions:
(defvar *foo* nil)
global deadlines into account: TO-SEC, TO-USEC, STOP-SEC, STOP-USEC,
DEADLINEP.
-TO-SEC and TO-USEC indicate the relative timeout in seconds and microsconds.
+TO-SEC and TO-USEC indicate the relative timeout in seconds and microseconds.
STOP-SEC and STOP-USEC indicate the absolute timeout in seconds and
microseconds. DEADLINEP is true if the returned values reflect a global
deadline instead of the local timeout indicated by SECONDS.
:INTERRUPTED-FRAME
specifies the first interrupted frame on the stack \(typically the frame
- where the error occured, as opposed to error handling frames) if any,
+ where the error occurred, as opposed to error handling frames) if any,
otherwise behaving as :CURRENT-FRAME.
:DEBUGGER-FRAME
(defvar *auto-eval-in-frame* t
#!+sb-doc
"When set (the default), evaluations in the debugger's command loop occur
- relative to the current frame's environment without the need of debugger
- forms that explicitly control this kind of evaluation.")
+relative to the current frame's environment without the need of debugger
+forms that explicitly control this kind of evaluation.")
(defun debug-eval (expr)
(cond ((not (and (fboundp 'compile) *auto-eval-in-frame*))
evaluated before each evaluation of the body Forms. When the Test is true,
the Exit-Forms are evaluated as a PROGN, with the result being the value
of the DO. A block named NIL is established around the entire expansion,
- allowing RETURN to be used as an laternate exit mechanism."
+ allowing RETURN to be used as an alternate exit mechanism."
(frob-do-body varlist endlist body 'let* 'setq 'do* nil))
;;; DOTIMES and DOLIST could be defined more concisely using
(sb!xc:define-setf-expander ldb (bytespec place &environment env)
#!+sb-doc
"The first argument is a byte specifier. The second is any place form
- acceptable to SETF. Replace the specified byte of the number in this
- place with bits from the low-order end of the new value."
+acceptable to SETF. Replace the specified byte of the number in this
+place with bits from the low-order end of the new value."
(declare (type sb!c::lexenv env))
(multiple-value-bind (dummies vals newval setter getter)
(sb!xc:get-setf-expansion place env)
(sb!xc:define-setf-expander mask-field (bytespec place &environment env)
#!+sb-doc
"The first argument is a byte specifier. The second is any place form
- acceptable to SETF. Replaces the specified byte of the number in this place
- with bits from the corresponding position in the new value."
+acceptable to SETF. Replaces the specified byte of the number in this place
+with bits from the corresponding position in the new value."
(declare (type sb!c::lexenv env))
(multiple-value-bind (dummies vals newval setter getter)
(sb!xc:get-setf-expansion place env)
"Delete the specified FILE.
If FILE is a stream, on Windows the stream is closed immediately. On Unix
-plaforms the stream remains open, allowing IO to continue: the OS resources
+platforms the stream remains open, allowing IO to continue: the OS resources
associated with the deleted file remain available till the stream is closed as
per standard Unix unlink() behaviour."
(let* ((pathname (translate-logical-pathname
container specified by designated PATHNAME, such as a .so on an ELF platform.
Locating the shared object follows standard rules of the platform, consult the
-manual page for dlopen(3) for details. Typically paths speficied by
+manual page for dlopen(3) for details. Typically paths specified by
environment variables such as LD_LIBRARY_PATH are searched if the PATHNAME has
no directory, but on some systems (eg. Mac OS X) search may happen even if
PATHNAME is absolute. (On Windows LoadLibrary is used instead of dlopen(3).)
-On non-Windows platoforms calling LOAD-SHARED-OBJECT again with an PATHNAME
+On non-Windows platforms calling LOAD-SHARED-OBJECT again with a PATHNAME
EQUAL to the designated pathname of a previous call will replace the old
-definitions; if a symbol was previously referenced thru the object and is not
-present in the reloaded version an error will be signalled. Reloading may not
-work as expected if user or library-code has called dlopen(3) on the same
-shared object.
+definitions; if a symbol was previously referenced through the object and
+is not present in the reloaded version an error will be signalled. Reloading
+may not work as expected if user or library-code has called dlopen(3) on the
+same shared object.
LOAD-SHARED-OBJECT interacts with SB-EXT:SAVE-LISP-AND-DIE:
Consequences are undefined if HASH-TABLE is mutated during execution of BODY,
except for changing or removing elements corresponding to the current key. The
-applies to all threads, not just the curren one -- even for synchronized
+applies to all threads, not just the current one -- even for synchronized
hash-tables. If the table may be mutated by another thread during iteration,
use eg. SB-EXT:WITH-LOCKED-HASH-TABLE to protect the WITH-HASH-TABLE-ITERATOR
for."
(defun gcd (&rest integers)
#!+sb-doc
"Return the greatest common divisor of the arguments, which must be
- integers. Gcd with no arguments is defined to be 0."
+ integers. GCD with no arguments is defined to be 0."
(case (length integers)
(0 0)
(1 (abs (the integer (nth 0 integers))))
"Output a conditional newline to STREAM (which defaults to
*STANDARD-OUTPUT*) if it is a pretty-printing stream, and do
nothing if not. KIND can be one of:
- :LINEAR - A line break is inserted if and only if the immediatly
+ :LINEAR - A line break is inserted if and only if the immediately
containing section cannot be printed on one line.
:MISER - Same as LINEAR, but only if ``miser-style'' is in effect.
(See *PRINT-MISER-WIDTH*.)
line and miser-style is in effect.
:MANDATORY - A line break is always inserted.
When a line break is inserted by any type of conditional newline, any
- blanks that immediately precede the conditional newline are ommitted
+ blanks that immediately precede the conditional newline are omitted
from the output and indentation is introduced at the beginning of the
next line. (See PPRINT-INDENT.)"
(declare (type (member :linear :miser :fill :mandatory) kind)
(:copier nil))
#!+sb-doc
"A READTABLE is a data structure that maps characters into syntax
- types for the Common Lisp expression reader."
+types for the Common Lisp expression reader."
;; The CHARACTER-ATTRIBUTE-TABLE is a vector of BASE-CHAR-CODE-LIMIT
;; integers for describing the character type. Conceptually, there
;; are 4 distinct "primary" character attributes:
;;; Add a new handler to *descriptor-handlers*.
(defun add-fd-handler (fd direction function)
#!+sb-doc
- "Arange to call FUNCTION whenever FD is usable. DIRECTION should be
+ "Arrange to call FUNCTION whenever FD is usable. DIRECTION should be
either :INPUT or :OUTPUT. The value returned should be passed to
SYSTEM:REMOVE-FD-HANDLER when it is no longer needed."
(unless (member direction '(:input :output))
;;; Search *descriptor-handlers* for any reference to fd, and nuke 'em.
(defun invalidate-descriptor (fd)
#!+sb-doc
- "Remove any handers refering to fd. This should only be used when attempting
- to recover from a detected inconsistancy."
+ "Remove any handlers referring to FD. This should only be used when attempting
+ to recover from a detected inconsistency."
(with-descriptor-handlers
(setf *descriptor-handlers*
(delete fd *descriptor-handlers*
(defun string (x)
#!+sb-doc
"Coerces X into a string. If X is a string, X is returned. If X is a
- symbol, X's pname is returned. If X is a character then a one element
+ symbol, its name is returned. If X is a character then a one element
string containing that character is returned. If X cannot be coerced
into a string, an error occurs."
(cond ((stringp x) x)
* When TYPE is a foreign array type, an array of that type is
allocated, and a pointer to it is returned. Note that you
- must use DEREF to first access the arrey through the pointer.
+ must use DEREF to first access the array through the pointer.
If supplied, SIZE is used as the first dimension for the array.
;;; Dereference the alien and return the results.
(defun deref (alien &rest indices)
#!+sb-doc
- "De-reference an Alien pointer or array. If an array, the indices are used
+ "Dereference an Alien pointer or array. If an array, the indices are used
as the indices of the array element to access. If a pointer, one index can
optionally be specified, giving the equivalent of C pointer arithmetic."
(declare (type alien-value alien)
(defun alien-funcall (alien &rest args)
#!+sb-doc
"Call the foreign function ALIEN with the specified arguments. ALIEN's
- type specifies the argument and result types."
+type specifies the argument and result types."
(declare (type alien-value alien))
(let ((type (alien-value-type alien)))
(typecase type
#!+sb-doc
"DEFINE-ALIEN-ROUTINE Name Result-Type {(Arg-Name Arg-Type [Style])}*
- Define a foreign interface function for the routine with the specified NAME.
- Also automatically DECLAIM the FTYPE of the defined function.
-
- NAME may be either a string, a symbol, or a list of the form (string symbol).
-
- RETURN-TYPE is the alien type for the function return value. VOID may be
- used to specify a function with no result.
-
- The remaining forms specify individual arguments that are passed to the
- routine. ARG-NAME is a symbol that names the argument, primarily for
- documentation. ARG-TYPE is the C type of the argument. STYLE specifies the
- way that the argument is passed.
-
- :IN
- An :IN argument is simply passed by value. The value to be passed is
- obtained from argument(s) to the interface function. No values are
- returned for :In arguments. This is the default mode.
-
- :OUT
- The specified argument type must be a pointer to a fixed sized object.
- A pointer to a preallocated object is passed to the routine, and the
- the object is accessed on return, with the value being returned from
- the interface function. :OUT and :IN-OUT cannot be used with pointers
- to arrays, records or functions.
-
- :COPY
- This is similar to :IN, except that the argument values are stored
- on the stack, and a pointer to the object is passed instead of
- the value itself.
-
- :IN-OUT
- This is a combination of :OUT and :COPY. A pointer to the argument is
- passed, with the object being initialized from the supplied argument
- and the return value being determined by accessing the object on
- return."
+Define a foreign interface function for the routine with the specified NAME.
+Also automatically DECLAIM the FTYPE of the defined function.
+
+NAME may be either a string, a symbol, or a list of the form (string symbol).
+
+RETURN-TYPE is the alien type for the function return value. VOID may be
+used to specify a function with no result.
+
+The remaining forms specify individual arguments that are passed to the
+routine. ARG-NAME is a symbol that names the argument, primarily for
+documentation. ARG-TYPE is the C type of the argument. STYLE specifies the
+way that the argument is passed.
+
+:IN
+ An :IN argument is simply passed by value. The value to be passed is
+ obtained from argument(s) to the interface function. No values are
+ returned for :In arguments. This is the default mode.
+
+:OUT
+ The specified argument type must be a pointer to a fixed sized object.
+ A pointer to a preallocated object is passed to the routine, and the
+ the object is accessed on return, with the value being returned from
+ the interface function. :OUT and :IN-OUT cannot be used with pointers
+ to arrays, records or functions.
+
+:COPY
+ This is similar to :IN, except that the argument values are stored
+ on the stack, and a pointer to the object is passed instead of
+ the value itself.
+
+:IN-OUT
+ This is a combination of :OUT and :COPY. A pointer to the argument is
+ passed, with the object being initialized from the supplied argument
+ and the return value being determined by accessing the object on
+ return."
(multiple-value-bind (lisp-name alien-name)
(pick-lisp-and-alien-names name)
(collect ((docs) (lisp-args) (lisp-arg-types)
function with the same specifier already exists.")
(defvar *alien-callback-wrappers* (make-hash-table :test #'equal)
- "Cache of existing lisp weappers, indexed with SPECIFER. Used for memoization:
+ "Cache of existing lisp wrappers, indexed with SPECIFER. Used for memoization:
we don't create new wrappers if one for the same specifier already exists.")
(defvar *alien-callback-trampolines* (make-array 32 :fill-pointer 0 :adjustable t)
"Lisp trampoline store: assembler wrappers contain indexes to this, and
-ENTER-ALIEN-CALLBACK pulls the corresponsing trampoline out and calls it.")
+ENTER-ALIEN-CALLBACK pulls the corresponding trampoline out and calls it.")
(defun %alien-callback-sap (specifier result-type argument-types function wrapper
&optional call-type)
;; We want to use objects of type FOO as keys (by their
;; names.) EQUALP would work, but would make the names
- ;; case-insensitive -- wich we don't want.
+ ;; case-insensitive -- which we don't want.
(defstruct foo (name nil :type (or null string)))
;; Define an equivalence test function and a hash function.
&optional
(defaults *default-pathname-defaults*))
#!+sb-doc
- "Return an abbreviated pathname sufficent to identify the pathname relative
+ "Return an abbreviated pathname sufficient to identify the pathname relative
to the defaults."
(declare (type pathname-designator pathname))
(with-pathname (pathname pathname)
The file should contain a single form, suitable for use with
\(SETF LOGICAL-PATHNAME-TRANSLATIONS).
-Note: behaviour of this function is higly implementation dependent, and
-historically it used to be a no-op in SBcL -- the current approach is somewhat
+Note: behaviour of this function is highly implementation dependent, and
+historically it used to be a no-op in SBCL -- the current approach is somewhat
experimental and subject to change."
(declare (type string host)
(values (member t nil)))
- If STATE is a random state, return a copy of it.
- If STATE is T, return a randomly initialized state (using operating-system
provided randomness where available, otherwise a poor substitute based on
- internal time and pid).
+ internal time and PID).
See SB-EXT:SEED-RANDOM-STATE for a SBCL extension to this functionality."
(/show0 "entering MAKE-RANDOM-STATE")
any time."
(thread-%alive-p thread))
-(defun thread-emphemeral-p (thread)
+(defun thread-ephemeral-p (thread)
#!+sb-doc
"Return T if THREAD is `ephemeral', which indicates that this thread is
used by SBCL for internal purposes, and specifically that it knows how to
(defun semaphore-notification-status (semaphore-notification)
#!+sb-doc
"Returns T if a WAIT-ON-SEMAPHORE or TRY-SEMAPHORE using
-SEMAPHORE-NOTICATION has succeeded since the notification object was created
+SEMAPHORE-NOTIFICATION has succeeded since the notification object was created
or cleared."
(barrier (:read))
(semaphore-notification-%status semaphore-notification))
the function returns. The return values of FUNCTION are kept around
and can be retrieved by JOIN-THREAD.
-Invoking the initial ABORT restart estabilished by MAKE-THREAD
+Invoking the initial ABORT restart established by MAKE-THREAD
terminates the thread.
See also: RETURN-FROM-THREAD, ABORT-THREAD."
TIMEOUT occurs or the process exits: when main thread exits, the
entire process exits.
-NOTE: Return convention in case of a timeout is exprimental and
+NOTE: Return convention in case of a timeout is experimental and
subject to change."
(let ((lock (thread-result-lock thread))
(got-it nil)
given that asynch-unwind-safety does not compose: a function calling
only asynch-unwind-safe function isn't automatically asynch-unwind-safe.
- This means that in order for an asych unwind to be safe, the entire
+ This means that in order for an asynch unwind to be safe, the entire
callstack at the point of interruption needs to be asynch-unwind-safe.
* In addition to asynch-unwind-safety you must consider the issue of
- re-entrancy. INTERRUPT-THREAD can cause function that are never normally
+ reentrancy. INTERRUPT-THREAD can cause function that are never normally
called recursively to be re-entered during their dynamic contour,
which may cause them to misbehave. (Consider binding of special variables,
values of global variables, etc.)
-Take togather, these two restrict the \"safe\" things to do using
+Take together, these two restrict the \"safe\" things to do using
INTERRUPT-THREAD to a fairly minimal set. One useful one -- exclusively for
interactive development use is using it to force entry to debugger to inspect
the state of a thread:
;;; function, report the times.
(defun call-with-timing (timer function &rest arguments)
#!+sb-doc
- "Calls FUNCTION with ARGUMENTS, and gathers timing infomation about it.
+ "Calls FUNCTION with ARGUMENTS, and gathers timing information about it.
Then calls TIMER with keyword arguments describing the information collected.
Calls TIMER even if FUNCTION performs a non-local transfer of control. Finally
returns values returned by FUNCTION.
(heap-extract-maximum contents :key keyfun :test #'<=))))
(defun priority-queue-insert (priority-queue new-item)
- "Add NEW-ITEM to PRIOIRITY-QUEUE."
+ "Add NEW-ITEM to PRIORITY-QUEUE."
(symbol-macrolet ((contents (%pqueue-contents priority-queue))
(keyfun (%pqueue-keyfun priority-queue)))
(heap-insert contents new-item :key keyfun :test #'<=)))
(defvar *args* ()
#!+sb-doc
"This variable is bound to the format arguments when an error is signalled
- by BARF or BURP.")
+by BARF or BURP.")
(defvar *ignored-errors* (make-hash-table :test 'equal))
(defvar *burp-action* :warn
#!+sb-doc
"Action taken by the BURP function when a possible compiler bug is detected.
- One of :WARN, :ERROR or :NONE.")
+One of :WARN, :ERROR or :NONE.")
(declaim (type (member :warn :error :none) *burp-action*))
;;; Called when something funny but possibly correct is noticed.
Inherit all arguments and properties of the given format. Any
arguments defined in the current format definition will either modify
the copy of an existing argument (keeping in the same order with
- respect to when pre-filter's are called), if it has the same name as
+ respect to when prefilters are called), if it has the same name as
one, or be added to the end.
:DEFAULT-PRINTER printer-list
Use the given PRINTER-LIST as a format to print any instructions of
to a function, including &REST args.")
(def!constant sb!xc:lambda-parameters-limit sb!xc:most-positive-fixnum
#!+sb-doc
- "The exclusive upper bound on the number of parameters which may be specifed
+ "The exclusive upper bound on the number of parameters which may be specified
in a given lambda list. This is actually the limit on required and &OPTIONAL
parameters. With &KEY and &AUX you can get more.")
(def!constant sb!xc:multiple-values-limit sb!xc:most-positive-fixnum
(defvar *efficiency-note-cost-threshold* 5
#!+sb-doc
- "This is the minumum cost difference between the chosen implementation and
+ "This is the minimum cost difference between the chosen implementation and
the next alternative that justifies an efficiency note.")
(declaim (type index *efficiency-note-cost-threshold*))
(defparameter *max-optimize-iterations* 3 ; ARB
#!+sb-doc
"The upper limit on the number of times that we will consecutively do IR1
- optimization that doesn't introduce any new code. A finite limit is
- necessary, since type inference may take arbitrarily long to converge.")
+optimization that doesn't introduce any new code. A finite limit is
+necessary, since type inference may take arbitrarily long to converge.")
(defevent ir1-optimize-until-done "IR1-OPTIMIZE-UNTIL-DONE called")
(defevent ir1-optimize-maxed-out "hit *MAX-OPTIMIZE-ITERATIONS* limit")
(defun restrict-compiler-policy (&optional quality (min 0))
#!+sb-doc
- "Assing a minimum value to an optimization quality. QUALITY is the name of
+ "Assign a minimum value to an optimization quality. QUALITY is the name of
the optimization quality to restrict, and MIN (defaulting to zero) is the
minimum allowed value.
((open-p :initform t
:accessor stream-open-p))
#+sb-doc
- (:documentation "the base class for all Gray streams")))
+ (:documentation "Base class for all Gray streams.")))
;;; Define the stream classes.
(defclass fundamental-input-stream (fundamental-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray input streams"))
+ (:documentation "Superclass of all Gray input streams."))
(defclass fundamental-output-stream (fundamental-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray output streams"))
+ (:documentation "Superclass of all Gray output streams."))
(defclass fundamental-character-stream (fundamental-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray streams whose element-type is a subtype of character"))
+ (:documentation
+ "Superclass of all Gray streams whose element-type is a subtype of character."))
(defclass fundamental-binary-stream (fundamental-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray streams whose element-type is a subtype of unsigned-byte or signed-byte"))
+ (:documentation "Superclass of all Gray streams whose element-type
+is a subtype of unsigned-byte or signed-byte."))
(defclass fundamental-character-input-stream
(fundamental-input-stream fundamental-character-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray input streams whose element-type is a subtype of character"))
+ (:documentation "Superclass of all Gray input streams whose element-type
+is a subtype of character."))
(defclass fundamental-character-output-stream
(fundamental-output-stream fundamental-character-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray output streams whose element-type is a subtype of character"))
+ (:documentation "Superclass of all Gray output streams whose element-type
+is a subtype of character."))
(defclass fundamental-binary-input-stream
(fundamental-input-stream fundamental-binary-stream) nil
#+sb-doc
- (:documentation "a superclass of all Gray input streams whose element-type is a subtype of unsigned-byte or signed-byte"))
+ (:documentation "Superclass of all Gray input streams whose element-type
+is a subtype of unsigned-byte or signed-byte."))
(defclass fundamental-binary-output-stream
(fundamental-output-stream fundamental-binary-stream) nil
- #+sb-doc
- (:documentation "a superclass of all Gray output streams whose element-type is a subtype of unsigned-byte or signed-byte"))
+ #+sb-doc
+ (:documentation "Superclass of all Gray output streams whose element-type
+is a subtype of unsigned-byte or signed-byte."))
\f
;;; This is not in the Gray stream proposal, so it is left here
;;; as example code.
(defgeneric stream-unread-char (stream character)
#+sb-doc
(:documentation
- "Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR.
+ "Undo the last call to STREAM-READ-CHAR, as in UNREAD-CHAR.
Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM
must define a method for this function."))
#+sb-doc
(:documentation
"Outputs a new line to the Stream if it is not positioned at the
- begining of a line. Returns T if it output a new line, nil
+ beginning of a line. Returns T if it output a new line, nil
otherwise. Used by FRESH-LINE. The default method uses
STREAM-START-LINE-P and STREAM-TERPRI."))
;;; otherwise dealing with STANDARD-INSTANCE-ACCESS becomes harder
;;; -- and slower -- than it needs to be.
(defconstant +slot-unbound+ '..slot-unbound..
- "SBCL specific extentions to MOP: if this value is read from an
+ "SBCL specific extensions to MOP: if this value is read from an
instance using STANDARD-INSTANCE-ACCESS, the slot is unbound.
Similarly, an :INSTANCE allocated slot can be made unbound by
assigning this to it using (SETF STANDARD-INSTANCE-ACCESS).
(unless (or (not (sb-thread:thread-alive-p thread))
(eql thread sb-thread:*current-thread*)
(member thread ,threads)
- (sb-thread:thread-emphemeral-p thread))
+ (sb-thread:thread-ephemeral-p thread))
(setf any-leftover thread)
(ignore-errors (sb-thread:terminate-thread thread))))
(when any-leftover
projects / sbcl.git / commitdiff