The branch "master" has been updated in SBCL:
via 54da325f13fb41669869aea688ae195426c0e231 (commit)
from 378a5e39c182b5c3ba14da80c157ad2c0021b25f (commit)
- Log -----------------------------------------------------------------
commit 54da325f13fb41669869aea688ae195426c0e231
Author: Stas Boukarev <stassats@...>
Date: Tue Nov 12 18:40:23 2013 +0400
Fix typos in docstrings and function names.
Includes an incompatibility change, sb-thread:thread-eMphemeral-p has
a typo, but it doesn't appear to be used anywhere outside of SBCL.
---
contrib/sb-cltl2/env.lisp | 6 +-
contrib/sb-concurrency/gate.lisp | 2 +-
contrib/sb-concurrency/queue.lisp | 2 +-
contrib/sb-introspect/introspect.lisp | 2 +-
contrib/sb-posix/interface.lisp | 13 +++---
contrib/sb-sprof/sb-sprof.lisp | 4 +-
package-data-list.lisp-expr | 4 +-
src/code/array.lisp | 12 +++---
src/code/cas.lisp | 2 +-
src/code/deadline.lisp | 2 +-
src/code/debug.lisp | 6 +-
src/code/defboot.lisp | 2 +-
src/code/early-setf.lisp | 8 ++--
src/code/filesys.lisp | 2 +-
src/code/foreign-load.lisp | 12 +++---
src/code/hash-table.lisp | 2 +-
src/code/numbers.lisp | 2 +-
src/code/pprint.lisp | 4 +-
src/code/readtable.lisp | 2 +-
src/code/serve-event.lisp | 6 +-
src/code/string.lisp | 2 +-
src/code/target-alieneval.lisp | 66 ++++++++++++++++----------------
src/code/target-hash-table.lisp | 2 +-
src/code/target-pathname.lisp | 6 +-
src/code/target-random.lisp | 2 +-
src/code/target-thread.lisp | 14 +++---
src/code/time.lisp | 2 +-
src/code/timer.lisp | 2 +-
src/compiler/debug.lisp | 4 +-
src/compiler/disassem.lisp | 2 +-
src/compiler/early-c.lisp | 2 +-
src/compiler/ltn.lisp | 2 +-
src/compiler/main.lisp | 4 +-
src/compiler/policy.lisp | 2 +-
src/pcl/gray-streams-class.lisp | 26 ++++++++-----
src/pcl/gray-streams.lisp | 4 +-
src/pcl/low.lisp | 2 +-
tests/test-util.lisp | 2 +-
38 files changed, 123 insertions(+), 118 deletions(-)
diff --git a/contrib/sb-cltl2/env.lisp b/contrib/sb-cltl2/env.lisp
index 7b479c8..3b90608 100644
--- a/contrib/sb-cltl2/env.lisp
+++ b/contrib/sb-cltl2/env.lisp
@@ -291,7 +291,7 @@ The second value is true if NAME is bound locally. This is currently
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:
@@ -414,8 +414,8 @@ the condition types that have been muffled."
(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)
diff --git a/contrib/sb-concurrency/gate.lisp b/contrib/sb-concurrency/gate.lisp
index b51c37c..c7f8b94 100644
--- a/contrib/sb-concurrency/gate.lisp
+++ b/contrib/sb-concurrency/gate.lisp
@@ -17,7 +17,7 @@
(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,
diff --git a/contrib/sb-concurrency/queue.lisp b/contrib/sb-concurrency/queue.lisp
index 9b0949e..4ffe171 100644
--- a/contrib/sb-concurrency/queue.lisp
+++ b/contrib/sb-concurrency/queue.lisp
@@ -45,7 +45,7 @@ Use ENQUEUE to add objects to the queue, and DEQUEUE to remove them."
(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)
diff --git a/contrib/sb-introspect/introspect.lisp b/contrib/sb-introspect/introspect.lisp
index 79706bb..385d02d 100644
--- a/contrib/sb-introspect/introspect.lisp
+++ b/contrib/sb-introspect/introspect.lisp
@@ -803,7 +803,7 @@ allocation.
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
diff --git a/contrib/sb-posix/interface.lisp b/contrib/sb-posix/interface.lisp
index 8025930..8e6be50 100644
--- a/contrib/sb-posix/interface.lisp
+++ b/contrib/sb-posix/interface.lisp
@@ -506,8 +506,8 @@ not supported."
: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
@@ -572,9 +572,8 @@ not supported."
(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?
@@ -653,8 +652,8 @@ not supported."
: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
diff --git a/contrib/sb-sprof/sb-sprof.lisp b/contrib/sb-sprof/sb-sprof.lisp
index 0ce3209..1c7d1ca 100644
--- a/contrib/sb-sprof/sb-sprof.lisp
+++ b/contrib/sb-sprof/sb-sprof.lisp
@@ -657,7 +657,7 @@ profiling, and :TIME for wallclock profiling.")
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.
@@ -704,7 +704,7 @@ The following keyword args are recognized:
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)
diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr
index 8adc3b5..94fe875 100644
--- a/package-data-list.lisp-expr
+++ b/package-data-list.lisp-expr
@@ -907,7 +907,7 @@ Lisp extension proposal by David N. Gray"
: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"
@@ -2046,7 +2046,7 @@ is a good idea, but see SB-SYS re. blurring of boundaries."
"THREAD-ERROR"
"THREAD-ERROR-THREAD"
"THREAD-ALIVE-P"
- "THREAD-EMPHEMERAL-P"
+ "THREAD-EPHEMERAL-P"
"THREAD-NAME"
"THREAD-YIELD"
"FOREIGN-THREAD"
diff --git a/src/code/array.lisp b/src/code/array.lisp
index 8055ac0..02425d1 100644
--- a/src/code/array.lisp
+++ b/src/code/array.lisp
@@ -589,8 +589,8 @@ of specialized arrays is supported."
(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))
@@ -600,7 +600,7 @@ of specialized arrays is supported."
(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))
@@ -785,10 +785,10 @@ of specialized arrays is supported."
;;; 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)))
@@ -797,7 +797,7 @@ of specialized arrays is supported."
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))))
diff --git a/src/code/cas.lisp b/src/code/cas.lisp
index 72e5800..9c1c611 100644
--- a/src/code/cas.lisp
+++ b/src/code/cas.lisp
@@ -21,7 +21,7 @@
(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)
diff --git a/src/code/deadline.lisp b/src/code/deadline.lisp
index d2577dc..7a0fc22 100644
--- a/src/code/deadline.lisp
+++ b/src/code/deadline.lisp
@@ -151,7 +151,7 @@ current real time."
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.
diff --git a/src/code/debug.lisp b/src/code/debug.lisp
index 1f63348..d7b9a62 100644
--- a/src/code/debug.lisp
+++ b/src/code/debug.lisp
@@ -269,7 +269,7 @@ is :DEBUGGER-FRAME.
: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
@@ -1175,8 +1175,8 @@ and LDB (the low-level debugger). See also ENABLE-DEBUGGER."
(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*))
diff --git a/src/code/defboot.lisp b/src/code/defboot.lisp
index c9fca38..1e915ca 100644
--- a/src/code/defboot.lisp
+++ b/src/code/defboot.lisp
@@ -324,7 +324,7 @@ evaluated as a PROGN."
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
diff --git a/src/code/early-setf.lisp b/src/code/early-setf.lisp
index 3cddab4..74a3a43 100644
--- a/src/code/early-setf.lisp
+++ b/src/code/early-setf.lisp
@@ -541,8 +541,8 @@
(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)
@@ -572,8 +572,8 @@
(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)
diff --git a/src/code/filesys.lisp b/src/code/filesys.lisp
index c10aabc..49218ae 100644
--- a/src/code/filesys.lisp
+++ b/src/code/filesys.lisp
@@ -485,7 +485,7 @@ file, then the associated file is renamed."
"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
diff --git a/src/code/foreign-load.lisp b/src/code/foreign-load.lisp
index 185d958..de6bbd4 100644
--- a/src/code/foreign-load.lisp
+++ b/src/code/foreign-load.lisp
@@ -39,17 +39,17 @@
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:
diff --git a/src/code/hash-table.lisp b/src/code/hash-table.lisp
index 4b3da96..c7afa7e 100644
--- a/src/code/hash-table.lisp
+++ b/src/code/hash-table.lisp
@@ -104,7 +104,7 @@ values are the key and the value of the next object.
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."
diff --git a/src/code/numbers.lisp b/src/code/numbers.lisp
index 5847707..40706af 100644
--- a/src/code/numbers.lisp
+++ b/src/code/numbers.lisp
@@ -1322,7 +1322,7 @@ the first."
(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))))
diff --git a/src/code/pprint.lisp b/src/code/pprint.lisp
index 24e7d97..5c1a353 100644
--- a/src/code/pprint.lisp
+++ b/src/code/pprint.lisp
@@ -679,7 +679,7 @@
"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*.)
@@ -691,7 +691,7 @@
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)
diff --git a/src/code/readtable.lisp b/src/code/readtable.lisp
index a033074..0df3891 100644
--- a/src/code/readtable.lisp
+++ b/src/code/readtable.lisp
@@ -52,7 +52,7 @@
(: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:
diff --git a/src/code/serve-event.lisp b/src/code/serve-event.lisp
index 8fd5321..b1a6eed 100644
--- a/src/code/serve-event.lisp
+++ b/src/code/serve-event.lisp
@@ -66,7 +66,7 @@
;;; 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))
@@ -90,8 +90,8 @@
;;; 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*
diff --git a/src/code/string.lisp b/src/code/string.lisp
index 72df091..b7c0035 100644
--- a/src/code/string.lisp
+++ b/src/code/string.lisp
@@ -15,7 +15,7 @@
(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)
diff --git a/src/code/target-alieneval.lisp b/src/code/target-alieneval.lisp
index e746b72..bc990ab 100644
--- a/src/code/target-alieneval.lisp
+++ b/src/code/target-alieneval.lisp
@@ -257,7 +257,7 @@ interpreted depends on TYPE:
* 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.
@@ -489,7 +489,7 @@ null byte.
;;; 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)
@@ -683,7 +683,7 @@ null byte.
(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
@@ -717,41 +717,41 @@ null byte.
#!+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.
+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).
+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.
+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.
+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.
+: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.
+: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.
+: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."
+: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)
@@ -860,12 +860,12 @@ memoization: we don't create new callbacks if one pointing to the correct
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)
diff --git a/src/code/target-hash-table.lisp b/src/code/target-hash-table.lisp
index 5c5bdb7..ba5f7d8 100644
--- a/src/code/target-hash-table.lisp
+++ b/src/code/target-hash-table.lisp
@@ -174,7 +174,7 @@ Examples:
;; 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.
diff --git a/src/code/target-pathname.lisp b/src/code/target-pathname.lisp
index 80cd3f9..f0123a9 100644
--- a/src/code/target-pathname.lisp
+++ b/src/code/target-pathname.lisp
@@ -991,7 +991,7 @@ system's syntax for files."
&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)
@@ -1697,8 +1697,8 @@ is returned.
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)))
diff --git a/src/code/target-random.lisp b/src/code/target-random.lisp
index aa36398..f886832 100644
--- a/src/code/target-random.lisp
+++ b/src/code/target-random.lisp
@@ -93,7 +93,7 @@ As per the Common Lisp standard,
- 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")
diff --git a/src/code/target-thread.lisp b/src/code/target-thread.lisp
index 99fc267..d037f45 100644
--- a/src/code/target-thread.lisp
+++ b/src/code/target-thread.lisp
@@ -220,7 +220,7 @@ potentially stale even before the function returns, as the thread may exit at
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
@@ -1022,7 +1022,7 @@ is initially NIL.")
(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))
@@ -1435,7 +1435,7 @@ list designator provided (defaults to no argument). Thread exits when
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."
@@ -1486,7 +1486,7 @@ Trying to join the main thread will cause JOIN-THREAD to block until
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)
@@ -1602,16 +1602,16 @@ With those caveats in mind, what you need to know when using it:
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:
diff --git a/src/code/time.lisp b/src/code/time.lisp
index 15d4c8d..1389742 100644
--- a/src/code/time.lisp
+++ b/src/code/time.lisp
@@ -393,7 +393,7 @@ normally during operations like SLEEP."
;;; 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.
diff --git a/src/code/timer.lisp b/src/code/timer.lisp
index 29dc0a8..ca4ffef 100644
--- a/src/code/timer.lisp
+++ b/src/code/timer.lisp
@@ -111,7 +111,7 @@
(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 #'<=)))
diff --git a/src/compiler/debug.lisp b/src/compiler/debug.lisp
index 6707533..f4be0a0 100644
--- a/src/compiler/debug.lisp
+++ b/src/compiler/debug.lisp
@@ -15,7 +15,7 @@
(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))
@@ -36,7 +36,7 @@
(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.
diff --git a/src/compiler/disassem.lisp b/src/compiler/disassem.lisp
index 22e3f9a..c1d7780 100644
--- a/src/compiler/disassem.lisp
+++ b/src/compiler/disassem.lisp
@@ -582,7 +582,7 @@
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
diff --git a/src/compiler/early-c.lisp b/src/compiler/early-c.lisp
index b313fcc..b772aa4 100644
--- a/src/compiler/early-c.lisp
+++ b/src/compiler/early-c.lisp
@@ -22,7 +22,7 @@
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
diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp
index 6dc4181..d2b162e 100644
--- a/src/compiler/ltn.lisp
+++ b/src/compiler/ltn.lisp
@@ -606,7 +606,7 @@
(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*))
diff --git a/src/compiler/main.lisp b/src/compiler/main.lisp
index 1bec50e..4463996 100644
--- a/src/compiler/main.lisp
+++ b/src/compiler/main.lisp
@@ -404,8 +404,8 @@ Examples:
(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")
diff --git a/src/compiler/policy.lisp b/src/compiler/policy.lisp
index c6b31aa..cadc959 100644
--- a/src/compiler/policy.lisp
+++ b/src/compiler/policy.lisp
@@ -19,7 +19,7 @@
(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.
diff --git a/src/pcl/gray-streams-class.lisp b/src/pcl/gray-streams-class.lisp
index c0051a1..0f2f5fb 100644
--- a/src/pcl/gray-streams-class.lisp
+++ b/src/pcl/gray-streams-class.lisp
@@ -16,44 +16,50 @@
((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."))
;;; This is not in the Gray stream proposal, so it is left here
;;; as example code.
diff --git a/src/pcl/gray-streams.lisp b/src/pcl/gray-streams.lisp
index 38eb79e..f182d4e 100644
--- a/src/pcl/gray-streams.lisp
+++ b/src/pcl/gray-streams.lisp
@@ -176,7 +176,7 @@
(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."))
@@ -403,7 +403,7 @@
#+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."))
diff --git a/src/pcl/low.lisp b/src/pcl/low.lisp
index a8e4122..0d06027 100644
--- a/src/pcl/low.lisp
+++ b/src/pcl/low.lisp
@@ -182,7 +182,7 @@
;;; 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).
diff --git a/tests/test-util.lisp b/tests/test-util.lisp
index 4d153d2..7ec458c 100644
--- a/tests/test-util.lisp
+++ b/tests/test-util.lisp
@@ -95,7 +95,7 @@
(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
-----------------------------------------------------------------------
hooks/post-receive
--
SBCL

Community

Help

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

I agree to receive quotes, newsletters and other information from sourceforge.net and its partners regarding IT services and products. I understand that I can withdraw my consent at any time. Please refer to our Privacy Policy or Contact Us for more details