rabbibotton /clog-ace
#clog
#clog-plugin

Enter comma separated tag names:

+

CLOG Plugin for the ACE Editor https://ace.c9.io/

source-id=1811 version=18 project-id=1769 project-version=0

Type GITHUB
Created at 2024-03-01 12:43:14 UTC
Source https://github.com/rabbibotton/clog-ace
Branch or tag main
Last seen commit 20be6292a96239db3ad06057cc4e2ccdac295a07
Release http://dist.ultralisp.org/archive/1811/rabbibotton-clog-ace-20240301124305.tgz
Systems
clog-ace.asd
clog-ace, clog-ace/tools
Distributions rabbibotton/clog-pluginsultralisp
Last check Finished 19 hours 59 seconds ago. There was an

Check Error

Traceback (most recent call last):
   0 File "unknown"
       In sb-impl::update-package-with-variance
     Args (#<package "BORDEAUX-THREADS-2"> "BT2" ("BORDEAUX-THREADS-2") #S(sb-c:definition-source-location
   :namestring "/tmp/checker/qlot/.qlot/dists/ultralisp/software/sionescu-bordeaux-threads-20240313171425/apiv2/pkgdcl.lisp"
   :indices 32769) nil nil (#<package "COMMON-LISP"> #<package "ALEXANDRIA"> #<package "GLOBAL-VARS">) (sb-ext:timeout) nil ("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR" "NOT-IMPLEMENTED" "THREAD"
 "THREAD-NAME" "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
 "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*" "CURRENT-THREAD"
 "ALL-THREADS" "START-MULTIPROCESSING" "INTERRUPT-THREAD" "SIGNAL-IN-THREAD"
 "WARN-IN-THREAD" "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
 "JOIN-THREAD" "ABNORMAL-EXIT" "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
 "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P" "LOCK-NAME" "LOCK-NATIVE-LOCK"
 "NATIVE-LOCK" "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
 "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK" "RELEASE-LOCK"
 "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK" "ACQUIRE-RECURSIVE-LOCK"
 "RELEASE-RECURSIVE-LOCK" "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
 "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE" "CONDITION-WAIT"
 "CONDITION-NOTIFY" "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
 "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE" "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
 "MAKE-ATOMIC-INTEGER" "ATOMIC-INTEGER-COMPARE-AND-SWAP" "ATOMIC-INTEGER-DECF"
 "ATOMIC-INTEGER-INCF" "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT") ("BT2") nil nil "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")
   1 File "unknown"
       In (flet "WITHOUT-INTERRUPTS-BODY-11" :in sb-thread::call-with-recursive-lock)
     Args ()
   2 File "unknown"
       In sb-thread::call-with-recursive-lock
     Args (#<function (flet sb-thread::with-recursive-lock-thunk :in sb-impl::%defpackage) {7F870A843B0B}> #<sb-thread:mutex "Package Graph Lock" owner: #<sb-thread:thread "main thread" running {1013C402B3}>> t nil)
   3 File "unknown"
       In sb-impl::%defpackage
     Args ("BT2" ("BORDEAUX-THREADS-2") nil nil nil ("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS") (("SB-EXT" "TIMEOUT")) nil ("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR" "NOT-IMPLEMENTED" "THREAD"
 "THREAD-NAME" "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
 "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*" "CURRENT-THREAD"
 "ALL-THREADS" "START-MULTIPROCESSING" "INTERRUPT-THREAD" "SIGNAL-IN-THREAD"
 "WARN-IN-THREAD" "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
 "JOIN-THREAD" "ABNORMAL-EXIT" "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
 "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P" "LOCK-NAME" "LOCK-NATIVE-LOCK"
 "NATIVE-LOCK" "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
 "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK" "RELEASE-LOCK"
 "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK" "ACQUIRE-RECURSIVE-LOCK"
 "RELEASE-RECURSIVE-LOCK" "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
 "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE" "CONDITION-WAIT"
 "CONDITION-NOTIFY" "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
 "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE" "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
 "MAKE-ATOMIC-INTEGER" "ATOMIC-INTEGER-COMPARE-AND-SWAP" "ATOMIC-INTEGER-DECF"
 "ATOMIC-INTEGER-INCF" "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT") ("BT2") nil nil #S(sb-c:definition-source-location
   :namestring "/tmp/checker/qlot/.qlot/dists/ultralisp/software/sionescu-bordeaux-threads-20240313171425/apiv2/pkgdcl.lisp"
   :indices 32769) "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")
   4 File "unknown"
       In sb-int:simple-eval-in-lexenv
     Args ((sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                      '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                      '(("SB-EXT" "TIMEOUT")) 'nil
                      '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                        "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                        "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                        "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                        "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                        "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                        "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                        "JOIN-THREAD" "ABNORMAL-EXIT" "ABNORMAL-EXIT-CONDITION"
                        "THREAD-YIELD" "LOCK" "LOCKP" "RECURSIVE-LOCK"
                        "RECURSIVE-LOCK-P" "LOCK-NAME" "LOCK-NATIVE-LOCK"
                        "NATIVE-LOCK" "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                        "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                        "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                        "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                        "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                        "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                        "CONDITION-WAIT" "CONDITION-NOTIFY"
                        "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                        "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE" "WAIT-ON-SEMAPHORE"
                        "ATOMIC-INTEGER" "MAKE-ATOMIC-INTEGER"
                        "ATOMIC-INTEGER-COMPARE-AND-SWAP" "ATOMIC-INTEGER-DECF"
                        "ATOMIC-INTEGER-INCF" "ATOMIC-INTEGER-VALUE" "TIMEOUT"
                        "WITH-TIMEOUT")
                      '("BT2") 'nil 'nil (sb-c:source-location)
                      "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.") #<NULL-LEXENV>)
   5 File "unknown"
       In sb-int:simple-eval-in-lexenv
     Args ((progn
 (sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                       '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                       '(("SB-EXT" "TIMEOUT")) 'nil
                       '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                         "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                         "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                         "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                         "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                         "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                         "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                         "JOIN-THREAD" "ABNORMAL-EXIT"
                         "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                         "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                         "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                         "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                         "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                         "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                         "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                         "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                         "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                         "CONDITION-WAIT" "CONDITION-NOTIFY"
                         "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                         "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                         "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                         "MAKE-ATOMIC-INTEGER"
                         "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                         "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                         "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                       '("BT2") 'nil 'nil (sb-c:source-location)
                       "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")) #<NULL-LEXENV>)
   6 File "unknown"
       In sb-ext:eval-tlf
     Args ((progn
 (sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                       '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                       '(("SB-EXT" "TIMEOUT")) 'nil
                       '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                         "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                         "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                         "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                         "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                         "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                         "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                         "JOIN-THREAD" "ABNORMAL-EXIT"
                         "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                         "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                         "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                         "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                         "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                         "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                         "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                         "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                         "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                         "CONDITION-WAIT" "CONDITION-NOTIFY"
                         "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                         "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                         "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                         "MAKE-ATOMIC-INTEGER"
                         "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                         "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                         "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                       '("BT2") 'nil 'nil (sb-c:source-location)
                       "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")) 0 #<NULL-LEXENV>)
   7 File "unknown"
       In (flet sb-c::frob :in sb-c::eval-compile-toplevel)
     Args ()
   8 File "unknown"
       In sb-c::eval-compile-toplevel
     Args (((sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                       '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                       '(("SB-EXT" "TIMEOUT")) 'nil
                       '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                         "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                         "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                         "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                         "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                         "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                         "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                         "JOIN-THREAD" "ABNORMAL-EXIT"
                         "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                         "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                         "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                         "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                         "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                         "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                         "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                         "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                         "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                         "CONDITION-WAIT" "CONDITION-NOTIFY"
                         "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                         "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                         "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                         "MAKE-ATOMIC-INTEGER"
                         "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                         "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                         "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                       '("BT2") 'nil 'nil (sb-c:source-location)
                       "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")) ((sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                       '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                       '(("SB-EXT" "TIMEOUT")) 'nil
                       '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                         "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                         "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                         "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                         "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                         "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                         "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                         "JOIN-THREAD" "ABNORMAL-EXIT"
                         "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                         "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                         "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                         "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                         "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                         "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                         "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                         "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                         "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                         "CONDITION-WAIT" "CONDITION-NOTIFY"
                         "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                         "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                         "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                         "MAKE-ATOMIC-INTEGER"
                         "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                         "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                         "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                       '("BT2") 'nil 'nil (sb-c:source-location)
                       "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.")
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                         '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                         '(("SB-EXT" "TIMEOUT")) 'nil
                         '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                           "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                           "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                           "*DEFAULT-SPECIAL-BINDINGS*"
                           "*STANDARD-IO-BINDINGS*" "CURRENT-THREAD"
                           "ALL-THREADS" "START-MULTIPROCESSING"
                           "INTERRUPT-THREAD" "SIGNAL-IN-THREAD"
                           "WARN-IN-THREAD" "ERROR-IN-THREAD" "DESTROY-THREAD"
                           "THREAD-ALIVE-P" "JOIN-THREAD" "ABNORMAL-EXIT"
                           "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                           "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                           "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                           "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                           "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                           "RELEASE-LOCK" "WITH-LOCK-HELD"
                           "MAKE-RECURSIVE-LOCK" "ACQUIRE-RECURSIVE-LOCK"
                           "RELEASE-RECURSIVE-LOCK" "WITH-RECURSIVE-LOCK-HELD"
                           "CONDITION-VARIABLE" "CONDITION-VARIABLE-P"
                           "MAKE-CONDITION-VARIABLE" "CONDITION-WAIT"
                           "CONDITION-NOTIFY" "CONDITION-BROADCAST" "SEMAPHORE"
                           "SEMAPHOREP" "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                           "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                           "MAKE-ATOMIC-INTEGER"
                           "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                           "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                           "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                         '("BT2") 'nil 'nil (sb-c:source-location)
                         "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages."))
 sb-c::original-source-start 0 0))
   9 File "unknown"
       In sb-c::process-toplevel-form
     Args ((sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                      '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                      '(("SB-EXT" "TIMEOUT")) 'nil
                      '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                        "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                        "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                        "*DEFAULT-SPECIAL-BINDINGS*" "*STANDARD-IO-BINDINGS*"
                        "CURRENT-THREAD" "ALL-THREADS" "START-MULTIPROCESSING"
                        "INTERRUPT-THREAD" "SIGNAL-IN-THREAD" "WARN-IN-THREAD"
                        "ERROR-IN-THREAD" "DESTROY-THREAD" "THREAD-ALIVE-P"
                        "JOIN-THREAD" "ABNORMAL-EXIT" "ABNORMAL-EXIT-CONDITION"
                        "THREAD-YIELD" "LOCK" "LOCKP" "RECURSIVE-LOCK"
                        "RECURSIVE-LOCK-P" "LOCK-NAME" "LOCK-NATIVE-LOCK"
                        "NATIVE-LOCK" "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                        "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                        "RELEASE-LOCK" "WITH-LOCK-HELD" "MAKE-RECURSIVE-LOCK"
                        "ACQUIRE-RECURSIVE-LOCK" "RELEASE-RECURSIVE-LOCK"
                        "WITH-RECURSIVE-LOCK-HELD" "CONDITION-VARIABLE"
                        "CONDITION-VARIABLE-P" "MAKE-CONDITION-VARIABLE"
                        "CONDITION-WAIT" "CONDITION-NOTIFY"
                        "CONDITION-BROADCAST" "SEMAPHORE" "SEMAPHOREP"
                        "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE" "WAIT-ON-SEMAPHORE"
                        "ATOMIC-INTEGER" "MAKE-ATOMIC-INTEGER"
                        "ATOMIC-INTEGER-COMPARE-AND-SWAP" "ATOMIC-INTEGER-DECF"
                        "ATOMIC-INTEGER-INCF" "ATOMIC-INTEGER-VALUE" "TIMEOUT"
                        "WITH-TIMEOUT")
                      '("BT2") 'nil 'nil (sb-c:source-location)
                      "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages.") ((eval-when (:compile-toplevel :load-toplevel :execute)
   (sb-impl::%defpackage "BT2" '("BORDEAUX-THREADS-2") 'nil 'nil 'nil
                         '("COMMON-LISP" "ALEXANDRIA" "GLOBAL-VARS")
                         '(("SB-EXT" "TIMEOUT")) 'nil
                         '("*SUPPORTS-THREADS-P*" "BORDEAUX-THREADS-ERROR"
                           "NOT-IMPLEMENTED" "THREAD" "THREAD-NAME"
                           "THREAD-NATIVE-THREAD" "THREADP" "MAKE-THREAD"
                           "*DEFAULT-SPECIAL-BINDINGS*"
                           "*STANDARD-IO-BINDINGS*" "CURRENT-THREAD"
                           "ALL-THREADS" "START-MULTIPROCESSING"
                           "INTERRUPT-THREAD" "SIGNAL-IN-THREAD"
                           "WARN-IN-THREAD" "ERROR-IN-THREAD" "DESTROY-THREAD"
                           "THREAD-ALIVE-P" "JOIN-THREAD" "ABNORMAL-EXIT"
                           "ABNORMAL-EXIT-CONDITION" "THREAD-YIELD" "LOCK"
                           "LOCKP" "RECURSIVE-LOCK" "RECURSIVE-LOCK-P"
                           "LOCK-NAME" "LOCK-NATIVE-LOCK" "NATIVE-LOCK"
                           "NATIVE-LOCK-P" "NATIVE-RECURSIVE-LOCK"
                           "NATIVE-RECURSIVE-LOCK-P" "MAKE-LOCK" "ACQUIRE-LOCK"
                           "RELEASE-LOCK" "WITH-LOCK-HELD"
                           "MAKE-RECURSIVE-LOCK" "ACQUIRE-RECURSIVE-LOCK"
                           "RELEASE-RECURSIVE-LOCK" "WITH-RECURSIVE-LOCK-HELD"
                           "CONDITION-VARIABLE" "CONDITION-VARIABLE-P"
                           "MAKE-CONDITION-VARIABLE" "CONDITION-WAIT"
                           "CONDITION-NOTIFY" "CONDITION-BROADCAST" "SEMAPHORE"
                           "SEMAPHOREP" "MAKE-SEMAPHORE" "SIGNAL-SEMAPHORE"
                           "WAIT-ON-SEMAPHORE" "ATOMIC-INTEGER"
                           "MAKE-ATOMIC-INTEGER"
                           "ATOMIC-INTEGER-COMPARE-AND-SWAP"
                           "ATOMIC-INTEGER-DECF" "ATOMIC-INTEGER-INCF"
                           "ATOMIC-INTEGER-VALUE" "TIMEOUT" "WITH-TIMEOUT")
                         '("BT2") 'nil 'nil (sb-c:source-location)
                         "BORDEAUX-THREADS is a proposed standard for a minimal
  MP/threading interface. It is similar to the CLIM-SYS threading and
  lock support, but for the following broad differences:

  1) Some behaviours are defined in additional detail: attention has
     been given to special variable interaction, whether and when
     cleanup forms are run. Some behaviours are defined in less
     detail: an implementation that does not support multiple
     threads is not required to use a new list (nil) for a lock, for
     example.

  2) Many functions which would be difficult, dangerous or inefficient
     to provide on some implementations have been removed. Chiefly
     these are functions such as thread-wait which expect for
     efficiency that the thread scheduler is written in Lisp and
     'hookable', which can't sensibly be done if the scheduler is
     external to the Lisp image, or the system has more than one CPU.

  3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
     added.

  4) Posix-style condition variables have been added, as it's not
     otherwise possible to implement them correctly using the other
     operations that are specified.

  Threads may be implemented using whatever applicable techniques are
  provided by the operating system: user-space scheduling,
  kernel-based LWPs or anything else that does the job.

  To avoid conflict with existing MP/threading interfaces in
  implementations, these symbols live in the BORDEAUX-THREADS-2 package.
  Implementations and/or users may also make them visible or exported
  in other more traditionally named packages."))
 sb-c::original-source-start 0 0) (:compile-toplevel))
Condition sb-kernel:simple-package-error: BT2 is a nickname for the package BORDEAUX-THREADS-2
error. Next check will be made in 6 days 4 hours.