id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
43,018 | bundle.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/toolchain/bundle.lisp | ;;;; -------------------------------------------------------------------------
;;;; ASDF-Bundle
(uiop/package:define-package :asdf/bundle
(:recycle :asdf/bundle :asdf)
(:use :uiop/common-lisp :uiop :asdf/upgrade
:asdf/component :asdf/system :asdf/find-system :asdf/find-component :asdf/operation
:asdf/action :asdf/lisp-action :asdf/plan :asdf/operate :asdf/defsystem)
(:export
#:bundle-op #:bundle-type #:program-system
#:bundle-system #:bundle-pathname-type #:direct-dependency-files
#:monolithic-op #:monolithic-bundle-op #:operation-monolithic-p
#:basic-compile-bundle-op #:prepare-bundle-op
#:compile-bundle-op #:load-bundle-op #:monolithic-compile-bundle-op #:monolithic-load-bundle-op
#:lib-op #:monolithic-lib-op
#:dll-op #:monolithic-dll-op
#:deliver-asd-op #:monolithic-deliver-asd-op
#:program-op #:image-op #:compiled-file #:precompiled-system #:prebuilt-system
#:user-system-p #:user-system #:trivial-system-p
#:prologue-code #:epilogue-code #:static-library))
(in-package :asdf/bundle)
(with-upgradability ()
(defclass bundle-op (basic-compile-op)
;; NB: use of instance-allocated slots for operations is DEPRECATED
;; and only supported in a temporary fashion for backward compatibility.
;; Supported replacement: Define slots on program-system instead.
((bundle-type :initform :no-output-file :reader bundle-type :allocation :class))
(:documentation "base class for operations that bundle outputs from multiple components"))
(defclass monolithic-op (operation) ()
(:documentation "A MONOLITHIC operation operates on a system *and all of its
dependencies*. So, for example, a monolithic concatenate operation will
concatenate together a system's components and all of its dependencies, but a
simple concatenate operation will concatenate only the components of the system
itself."))
(defclass monolithic-bundle-op (bundle-op monolithic-op)
;; Old style way of specifying prologue and epilogue on ECL: in the monolithic operation.
;; DEPRECATED. Supported replacement: Define slots on program-system instead.
((prologue-code :initform nil :accessor prologue-code)
(epilogue-code :initform nil :accessor epilogue-code))
(:documentation "operations that are both monolithic-op and bundle-op"))
(defclass program-system (system)
;; New style (ASDF3.1) way of specifying prologue and epilogue on ECL: in the system
((prologue-code :initform nil :initarg :prologue-code :reader prologue-code)
(epilogue-code :initform nil :initarg :epilogue-code :reader epilogue-code)
(no-uiop :initform nil :initarg :no-uiop :reader no-uiop)
(prefix-lisp-object-files :initarg :prefix-lisp-object-files
:initform nil :accessor prefix-lisp-object-files)
(postfix-lisp-object-files :initarg :postfix-lisp-object-files
:initform nil :accessor postfix-lisp-object-files)
(extra-object-files :initarg :extra-object-files
:initform nil :accessor extra-object-files)
(extra-build-args :initarg :extra-build-args
:initform nil :accessor extra-build-args)))
(defmethod prologue-code ((x system)) nil)
(defmethod epilogue-code ((x system)) nil)
(defmethod no-uiop ((x system)) nil)
(defmethod prefix-lisp-object-files ((x system)) nil)
(defmethod postfix-lisp-object-files ((x system)) nil)
(defmethod extra-object-files ((x system)) nil)
(defmethod extra-build-args ((x system)) nil)
(defclass link-op (bundle-op) ()
(:documentation "Abstract operation for linking files together"))
(defclass gather-operation (bundle-op)
((gather-operation :initform nil :allocation :class :reader gather-operation)
(gather-type :initform :no-output-file :allocation :class :reader gather-type))
(:documentation "Abstract operation for gathering many input files from a system"))
(defun operation-monolithic-p (op)
(typep op 'monolithic-op))
;; Dependencies of a gather-op are the actions of the dependent operation
;; for all the (sorted) required components for loading the system.
;; Monolithic operations typically use lib-op as the dependent operation,
;; and all system-level dependencies as required components.
;; Non-monolithic operations typically use compile-op as the dependent operation,
;; and all transitive sub-components as required components (excluding other systems).
(defmethod component-depends-on ((o gather-operation) (s system))
(let* ((mono (operation-monolithic-p o))
(go (make-operation (or (gather-operation o) 'compile-op)))
(bundle-p (typep go 'bundle-op))
;; In a non-mono operation, don't recurse to other systems.
;; In a mono operation gathering bundles, don't recurse inside systems.
(component-type (if mono (if bundle-p 'system t) '(not system)))
;; In the end, only keep system bundles or non-system bundles, depending.
(keep-component (if bundle-p 'system '(not system)))
(deps
;; Required-components only looks at the dependencies of an action, excluding the action
;; itself, so it may be safely used by an action recursing on its dependencies (which
;; may or may not be an overdesigned API, since in practice we never use it that way).
;; Therefore, if we use :goal-operation 'load-op :keep-operation 'load-op, which looks
;; cleaner, we will miss the load-op on the requested system itself, which doesn't
;; matter for a regular system, but matters, a lot, for a package-inferred-system.
;; Using load-op as the goal operation and basic-compile-op as the keep-operation works
;; for our needs of gathering all the files we want to include in a bundle.
;; Note that we use basic-compile-op rather than compile-op so it will still work on
;; systems when *load-system-operation* is load-bundle-op.
(required-components
s :other-systems mono :component-type component-type :keep-component keep-component
:goal-operation 'load-op :keep-operation 'basic-compile-op)))
`((,go ,@deps) ,@(call-next-method))))
;; Create a single fasl for the entire library
(defclass basic-compile-bundle-op (bundle-op)
((gather-type :initform #-(or clasp ecl mkcl) :fasl #+(or clasp ecl mkcl) :object
:allocation :class)
(bundle-type :initform :fasl :allocation :class))
(:documentation "Base class for compiling into a bundle"))
;; Analog to prepare-op, for load-bundle-op and compile-bundle-op
(defclass prepare-bundle-op (sideway-operation)
((sideway-operation
:initform #+(or clasp ecl mkcl) 'load-bundle-op #-(or clasp ecl mkcl) 'load-op
:allocation :class))
(:documentation "Operation class for loading the bundles of a system's dependencies"))
(defclass lib-op (link-op gather-operation non-propagating-operation)
((gather-type :initform :object :allocation :class)
(bundle-type :initform :lib :allocation :class))
(:documentation "Compile the system and produce a linkable static library (.a/.lib)
for all the linkable object files associated with the system. Compare with DLL-OP.
On most implementations, these object files only include extensions to the runtime
written in C or another language with a compiler producing linkable object files.
On CLASP, ECL, MKCL, these object files _also_ include the contents of Lisp files
themselves. In any case, this operation will produce what you need to further build
a static runtime for your system, or a dynamic library to load in an existing runtime."))
;; What works: on ECL, CLASP(?), MKCL, we link the many .o files from the system into the .so;
;; on other implementations, we combine (usually concatenate) the .fasl files into one.
(defclass compile-bundle-op (basic-compile-bundle-op selfward-operation gather-operation
#+(or clasp ecl mkcl) link-op)
((selfward-operation :initform '(prepare-bundle-op) :allocation :class))
(:documentation "This operator is an alternative to COMPILE-OP. Build a system
and all of its dependencies, but build only a single (\"monolithic\") FASL, instead
of one per source file, which may be more resource efficient. That monolithic
FASL should be loaded with LOAD-BUNDLE-OP, rather than LOAD-OP."))
(defclass load-bundle-op (basic-load-op selfward-operation)
((selfward-operation :initform '(prepare-bundle-op compile-bundle-op) :allocation :class))
(:documentation "This operator is an alternative to LOAD-OP. Build a system
and all of its dependencies, using COMPILE-BUNDLE-OP. The difference with
respect to LOAD-OP is that it builds only a single FASL, which may be
faster and more resource efficient."))
;; NB: since the monolithic-op's can't be sideway-operation's,
;; if we wanted lib-op, dll-op, deliver-asd-op to be sideway-operation's,
;; we'd have to have the monolithic-op not inherit from the main op,
;; but instead inherit from a basic-FOO-op as with basic-compile-bundle-op above.
(defclass dll-op (link-op gather-operation non-propagating-operation)
((gather-type :initform :object :allocation :class)
(bundle-type :initform :dll :allocation :class))
(:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
for all the linkable object files associated with the system. Compare with LIB-OP."))
(defclass deliver-asd-op (basic-compile-op selfward-operation)
((selfward-operation
;; TODO: implement link-op on all implementations, and make that
;; '(compile-bundle-op lib-op #-(or clasp ecl mkcl) dll-op)
:initform '(compile-bundle-op #+(or clasp ecl mkcl) lib-op)
:allocation :class))
(:documentation "produce an asd file for delivering the system as a single fasl"))
(defclass monolithic-deliver-asd-op (deliver-asd-op monolithic-bundle-op)
((selfward-operation
;; TODO: implement link-op on all implementations, and make that
;; '(monolithic-compile-bundle-op monolithic-lib-op #-(or clasp ecl mkcl) monolithic-dll-op)
:initform '(monolithic-compile-bundle-op #+(or clasp ecl mkcl) monolithic-lib-op)
:allocation :class))
(:documentation "produce fasl and asd files for combined system and dependencies."))
(defclass monolithic-compile-bundle-op
(basic-compile-bundle-op monolithic-bundle-op
#+(or clasp ecl mkcl) link-op gather-operation non-propagating-operation)
()
(:documentation "Create a single fasl for the system and its dependencies."))
(defclass monolithic-load-bundle-op (load-bundle-op monolithic-bundle-op)
((selfward-operation :initform 'monolithic-compile-bundle-op :allocation :class))
(:documentation "Load a single fasl for the system and its dependencies."))
(defclass monolithic-lib-op (lib-op monolithic-bundle-op non-propagating-operation)
((gather-type :initform :object :allocation :class))
(:documentation "Compile the system and produce a linkable static library (.a/.lib)
for all the linkable object files associated with the system or its dependencies. See LIB-OP."))
(defclass monolithic-dll-op (dll-op monolithic-bundle-op non-propagating-operation)
((gather-type :initform :object :allocation :class))
(:documentation "Compile the system and produce a dynamic loadable library (.so/.dll)
for all the linkable object files associated with the system or its dependencies. See LIB-OP"))
(defclass image-op (monolithic-bundle-op selfward-operation
#+(or clasp ecl mkcl) link-op #+(or clasp ecl mkcl) gather-operation)
((bundle-type :initform :image :allocation :class)
(gather-operation :initform 'lib-op :allocation :class)
#+(or clasp ecl mkcl) (gather-type :initform :static-library :allocation :class)
(selfward-operation :initform '(#-(or clasp ecl mkcl) load-op) :allocation :class))
(:documentation "create an image file from the system and its dependencies"))
(defclass program-op (image-op)
((bundle-type :initform :program :allocation :class))
(:documentation "create an executable file from the system and its dependencies"))
;; From the ASDF-internal bundle-type identifier, get a filesystem-usable pathname type.
(defun bundle-pathname-type (bundle-type)
(etypecase bundle-type
((or null string) ;; pass through nil or string literal
bundle-type)
((eql :no-output-file) ;; marker for a bundle-type that has NO output file
(error "No output file, therefore no pathname type"))
((eql :fasl) ;; the type of a fasl
#-(or clasp ecl mkcl) (compile-file-type) ; on image-based platforms, used as input and output
#+(or clasp ecl mkcl) "fasb") ; on C-linking platforms, only used as output for system bundles
((member :image)
#+allegro "dxl"
#+(and clisp os-windows) "exe"
#-(or allegro (and clisp os-windows)) "image")
;; NB: on CLASP and ECL these implementations, we better agree with
;; (compile-file-type :type bundle-type))
((eql :object) ;; the type of a linkable object file
(os-cond ((os-unix-p) "o")
((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "o" "obj"))))
((member :lib :static-library) ;; the type of a linkable library
(os-cond ((os-unix-p) "a")
((os-windows-p) (if (featurep '(:or :mingw32 :mingw64)) "a" "lib"))))
((member :dll :shared-library) ;; the type of a shared library
(os-cond ((os-macosx-p) "dylib") ((os-unix-p) "so") ((os-windows-p) "dll")))
((eql :program) ;; the type of an executable program
(os-cond ((os-unix-p) nil) ((os-windows-p) "exe")))))
;; Compute the output-files for a given bundle action
(defun bundle-output-files (o c)
(let ((bundle-type (bundle-type o)))
(unless (or (eq bundle-type :no-output-file) ;; NIL already means something regarding type.
(and (null (input-files o c)) (not (member bundle-type '(:image :program)))))
(let ((name (or (component-build-pathname c)
(let ((suffix
(unless (typep o 'program-op)
;; "." is no good separator for Logical Pathnames, so we use "--"
(if (operation-monolithic-p o)
"--all-systems"
;; These use a different type .fasb or .a instead of .fasl
#-(or clasp ecl mkcl) "--system"))))
(format nil "~A~@[~A~]" (component-name c) suffix))))
(type (bundle-pathname-type bundle-type)))
(values (list (subpathname (component-pathname c) name :type type))
(eq (class-of o) (coerce-class (component-build-operation c)
:package :asdf/interface
:super 'operation
:error nil)))))))
(defmethod output-files ((o bundle-op) (c system))
(bundle-output-files o c))
#-(or clasp ecl mkcl)
(progn
(defmethod perform ((o image-op) (c system))
(dump-image (output-file o c) :executable (typep o 'program-op)))
(defmethod perform :before ((o program-op) (c system))
(setf *image-entry-point* (ensure-function (component-entry-point c)))))
(defclass compiled-file (file-component)
((type :initform #-(or clasp ecl mkcl) (compile-file-type) #+(or clasp ecl mkcl) "fasb"))
(:documentation "Class for a file that is already compiled,
e.g. as part of the implementation, of an outer build system that calls into ASDF,
or of opaque libraries shipped along the source code."))
(defclass precompiled-system (system)
((build-pathname :initarg :fasl))
(:documentation "Class For a system that is delivered as a precompiled fasl"))
(defclass prebuilt-system (system)
((build-pathname :initarg :static-library :initarg :lib
:accessor prebuilt-system-static-library))
(:documentation "Class for a system delivered with a linkable static library (.a/.lib)")))
;;;
;;; BUNDLE-OP
;;;
;;; This operation takes all components from one or more systems and
;;; creates a single output file, which may be
;;; a FASL, a statically linked library, a shared library, etc.
;;; The different targets are defined by specialization.
;;;
(when-upgrading (:version "3.2.0")
;; Cancel any previously defined method
(defmethod initialize-instance :after ((instance bundle-op) &rest initargs &key &allow-other-keys)
(declare (ignore initargs))))
(with-upgradability ()
(defgeneric trivial-system-p (component))
(defun user-system-p (s)
(and (typep s 'system)
(not (builtin-system-p s))
(not (trivial-system-p s)))))
(eval-when (#-lispworks :compile-toplevel :load-toplevel :execute)
(deftype user-system () '(and system (satisfies user-system-p))))
;;;
;;; First we handle monolithic bundles.
;;; These are standalone systems which contain everything,
;;; including other ASDF systems required by the current one.
;;; A PROGRAM is always monolithic.
;;;
;;; MONOLITHIC SHARED LIBRARIES, PROGRAMS, FASL
;;;
(with-upgradability ()
(defun direct-dependency-files (o c &key (test 'identity) (key 'output-files) &allow-other-keys)
;; This function selects output files from direct dependencies;
;; your component-depends-on method must gather the correct dependencies in the correct order.
(while-collecting (collect)
(map-direct-dependencies
t o c #'(lambda (sub-o sub-c)
(loop :for f :in (funcall key sub-o sub-c)
:when (funcall test f) :do (collect f))))))
(defun pathname-type-equal-function (type)
#'(lambda (p) (equalp (pathname-type p) type)))
(defmethod input-files ((o gather-operation) (c system))
(unless (eq (bundle-type o) :no-output-file)
(direct-dependency-files
o c :key 'output-files
:test (pathname-type-equal-function (bundle-pathname-type (gather-type o))))))
;; Find the operation that produces a given bundle-type
(defun select-bundle-operation (type &optional monolithic)
(ecase type
((:dll :shared-library)
(if monolithic 'monolithic-dll-op 'dll-op))
((:lib :static-library)
(if monolithic 'monolithic-lib-op 'lib-op))
((:fasl)
(if monolithic 'monolithic-compile-bundle-op 'compile-bundle-op))
((:image)
'image-op)
((:program)
'program-op))))
;;;
;;; LOAD-BUNDLE-OP
;;;
;;; This is like ASDF's LOAD-OP, but using bundle fasl files.
;;;
(with-upgradability ()
(defmethod component-depends-on ((o load-bundle-op) (c system))
`((,o ,@(component-sideway-dependencies c))
(,(if (user-system-p c) 'compile-bundle-op 'load-op) ,c)
,@(call-next-method)))
(defmethod input-files ((o load-bundle-op) (c system))
(when (user-system-p c)
(output-files (find-operation o 'compile-bundle-op) c)))
(defmethod perform ((o load-bundle-op) (c system))
(when (input-files o c)
(perform-lisp-load-fasl o c)))
(defmethod mark-operation-done :after ((o load-bundle-op) (c system))
(mark-operation-done (find-operation o 'load-op) c)))
;;;
;;; PRECOMPILED FILES
;;;
;;; This component can be used to distribute ASDF systems in precompiled form.
;;; Only useful when the dependencies have also been precompiled.
;;;
(with-upgradability ()
(defmethod trivial-system-p ((s system))
(every #'(lambda (c) (typep c 'compiled-file)) (component-children s)))
(defmethod input-files ((o operation) (c compiled-file))
(list (component-pathname c)))
(defmethod perform ((o load-op) (c compiled-file))
(perform-lisp-load-fasl o c))
(defmethod perform ((o load-source-op) (c compiled-file))
(perform (find-operation o 'load-op) c))
(defmethod perform ((o operation) (c compiled-file))
nil))
;;;
;;; Pre-built systems
;;;
(with-upgradability ()
(defmethod trivial-system-p ((s prebuilt-system))
t)
(defmethod perform ((o link-op) (c prebuilt-system))
nil)
(defmethod perform ((o basic-compile-bundle-op) (c prebuilt-system))
nil)
(defmethod perform ((o lib-op) (c prebuilt-system))
nil)
(defmethod perform ((o dll-op) (c prebuilt-system))
nil)
(defmethod component-depends-on ((o gather-operation) (c prebuilt-system))
nil)
(defmethod output-files ((o lib-op) (c prebuilt-system))
(values (list (prebuilt-system-static-library c)) t)))
;;;
;;; PREBUILT SYSTEM CREATOR
;;;
(with-upgradability ()
(defmethod output-files ((o deliver-asd-op) (s system))
(list (make-pathname :name (component-name s) :type "asd"
:defaults (component-pathname s))))
(defmethod perform ((o deliver-asd-op) (s system))
(let* ((inputs (input-files o s))
(fasl (first inputs))
(library (second inputs))
(asd (first (output-files o s)))
(name (if (and fasl asd) (pathname-name asd) (return-from perform)))
(version (component-version s))
(dependencies
(if (operation-monolithic-p o)
;; We want only dependencies, and we use basic-load-op rather than load-op so that
;; this will keep working on systems when *load-system-operation* is load-bundle-op
(remove-if-not 'builtin-system-p
(required-components s :component-type 'system
:keep-operation 'basic-load-op))
(while-collecting (x) ;; resolve the sideway-dependencies of s
(map-direct-dependencies
t 'load-op s
#'(lambda (o c)
(when (and (typep o 'load-op) (typep c 'system))
(x c)))))))
(depends-on (mapcar 'coerce-name dependencies)))
(when (pathname-equal asd (system-source-file s))
(cerror "overwrite the asd file"
"~/asdf-action:format-action/ is going to overwrite the system definition file ~S ~
which is probably not what you want; you probably need to tweak your output translations."
(cons o s) asd))
(with-open-file (s asd :direction :output :if-exists :supersede
:if-does-not-exist :create)
(format s ";;; Prebuilt~:[~; monolithic~] ASDF definition for system ~A~%"
(operation-monolithic-p o) name)
(format s ";;; Built for ~A ~A on a ~A/~A ~A~%"
(lisp-implementation-type)
(lisp-implementation-version)
(software-type)
(machine-type)
(software-version))
(let ((*package* (find-package :asdf-user)))
(pprint `(defsystem ,name
:class prebuilt-system
:version ,version
:depends-on ,depends-on
:components ((:compiled-file ,(pathname-name fasl)))
,@(when library `(:lib ,(file-namestring library))))
s)
(terpri s)))))
#-(or clasp ecl mkcl)
(defmethod perform ((o basic-compile-bundle-op) (c system))
(let* ((input-files (input-files o c))
(fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test-not #'equalp))
(non-fasl-files (remove (compile-file-type) input-files :key #'pathname-type :test #'equalp))
(output-files (output-files o c))
(output-file (first output-files)))
(assert (eq (not input-files) (not output-files)))
(when input-files
(when non-fasl-files
(error "On ~A, asdf/bundle can only bundle FASL files, but these were also produced: ~S"
(implementation-type) non-fasl-files))
(when (or (prologue-code c) (epilogue-code c))
(error "prologue-code and epilogue-code are not supported on ~A"
(implementation-type)))
(with-staging-pathname (output-file)
(combine-fasls fasl-files output-file)))))
(defmethod input-files ((o load-op) (s precompiled-system))
(bundle-output-files (find-operation o 'compile-bundle-op) s))
(defmethod perform ((o load-op) (s precompiled-system))
(perform-lisp-load-fasl o s))
(defmethod component-depends-on ((o load-bundle-op) (s precompiled-system))
#+xcl (declare (ignorable o))
`((load-op ,s) ,@(call-next-method))))
#| ;; Example use:
(asdf:defsystem :precompiled-asdf-utils :class asdf::precompiled-system :fasl (asdf:apply-output-translations (asdf:system-relative-pathname :asdf-utils "asdf-utils.system.fasl")))
(asdf:load-system :precompiled-asdf-utils)
|#
#+(or clasp ecl mkcl)
(with-upgradability ()
#+ecl ;; doesn't work on clasp or mkcl (yet?).
(unless (use-ecl-byte-compiler-p)
(setf *load-system-operation* 'load-bundle-op))
(defun system-module-pathname (module)
(let ((name (coerce-name module)))
(some
'file-exists-p
(list
#+clasp (compile-file-pathname (make-pathname :name name :defaults "sys:") :output-type :object)
#+ecl (compile-file-pathname (make-pathname :name name :defaults "sys:") :type :lib)
#+ecl (compile-file-pathname (make-pathname :name name :defaults "sys:") :type :object)
#+mkcl (make-pathname :name name :type (bundle-pathname-type :lib) :defaults #p"sys:")
#+mkcl (make-pathname :name name :type (bundle-pathname-type :lib) :defaults #p"sys:contrib;")))))
(defun make-prebuilt-system (name &optional (pathname (system-module-pathname name)))
"Creates a prebuilt-system if PATHNAME isn't NIL."
(when pathname
(make-instance 'prebuilt-system
:name (coerce-name name)
:static-library (resolve-symlinks* pathname))))
(defmethod component-depends-on :around ((o image-op) (c system))
(destructuring-bind ((lib-op . deps)) (call-next-method)
(labels ((has-it-p (x) (find x deps :test 'equal :key 'coerce-name))
(ensure-linkable-system (x)
(unless (has-it-p x)
(or (if-let (s (find-system x))
(and (system-source-directory x)
(list s)))
(if-let (p (system-module-pathname x))
(list (make-prebuilt-system x p)))))))
`((,lib-op
,@(unless (no-uiop c)
(append (ensure-linkable-system "cmp")
(or (ensure-linkable-system "uiop")
(ensure-linkable-system "asdf"))))
,@deps)))))
(defmethod perform ((o link-op) (c system))
(let* ((object-files (input-files o c))
(output (output-files o c))
(bundle (first output))
(programp (typep o 'program-op))
(kind (bundle-type o)))
(when output
(apply 'create-image
bundle (append
(when programp (prefix-lisp-object-files c))
object-files
(when programp (postfix-lisp-object-files c)))
:kind kind
:prologue-code (when programp (prologue-code c))
:epilogue-code (when programp (epilogue-code c))
:build-args (when programp (extra-build-args c))
:extra-object-files (when programp (extra-object-files c))
:no-uiop (no-uiop c)
(when programp `(:entry-point ,(component-entry-point c))))))))
| 27,846 | Common Lisp | .lisp | 495 | 47.981818 | 180 | 0.654338 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | eff56efdd54015509a6074e58f04c235f65c95e06554cddb1c24fc00cd691d3c | 43,018 | [
330291
] |
43,019 | uffi-compat.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/uffi-compat/uffi-compat.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; uffi-compat.lisp --- UFFI compatibility layer for CFFI.
;;;
;;; Copyright (C) 2005-2006, James Bielman <jamesjb@jamesjb.com>
;;; Copyright (C) 2005-2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
;;; Code borrowed from UFFI is Copyright (c) Kevin M. Rosenberg.
(defpackage #:cffi-uffi-compat
(:nicknames #:uffi) ;; is this a good idea?
(:use #:cl)
(:export
;; immediate types
#:def-constant
#:def-foreign-type
#:def-type
#:null-char-p
;; aggregate types
#:def-enum
#:def-struct
#:get-slot-value
#:get-slot-pointer
#:def-array-pointer
#:deref-array
#:def-union
;; objects
#:allocate-foreign-object
#:free-foreign-object
#:with-foreign-object
#:with-foreign-objects
#:size-of-foreign-type
#:pointer-address
#:deref-pointer
#:ensure-char-character
#:ensure-char-integer
#:ensure-char-storable
#:null-pointer-p
#:make-null-pointer
#:make-pointer
#:+null-cstring-pointer+
#:char-array-to-pointer
#:with-cast-pointer
#:def-foreign-var
#:convert-from-foreign-usb8
#:def-pointer-var
;; string functions
#:convert-from-cstring
#:convert-to-cstring
#:free-cstring
#:with-cstring
#:with-cstrings
#:convert-from-foreign-string
#:convert-to-foreign-string
#:allocate-foreign-string
#:with-foreign-string
#:with-foreign-strings
#:foreign-string-length ; not implemented
#:string-to-octets
#:octets-to-string
#:foreign-encoded-octet-count
;; function call
#:def-function
;; libraries
#:find-foreign-library
#:load-foreign-library
#:default-foreign-library-type
#:foreign-library-types
;; os
#:getenv
#:run-shell-command
))
(in-package #:cffi-uffi-compat)
#+clisp
(eval-when (:compile-toplevel :load-toplevel :execute)
(when (equal (machine-type) "POWER MACINTOSH")
(pushnew :ppc *features*)))
(defun convert-uffi-type (uffi-type)
"Convert a UFFI primitive type to a CFFI type."
;; Many CFFI types are the same as UFFI. This list handles the
;; exceptions only.
(case uffi-type
(:cstring :pointer)
(:pointer-void :pointer)
(:pointer-self :pointer)
;; Although UFFI's documentation claims dereferencing :CHAR and
;; :UNSIGNED-CHAR returns characters, it actually returns
;; integers.
(:char :char)
(:unsigned-char :unsigned-char)
(:byte :char)
(:unsigned-byte :unsigned-char)
(t
(if (listp uffi-type)
(case (car uffi-type)
;; this is imho gross but it is what uffi does
(quote (convert-uffi-type (second uffi-type)))
(* :pointer)
(:array `(uffi-array ,(convert-uffi-type (second uffi-type))
,(third uffi-type)))
(:union (second uffi-type))
(:struct (convert-uffi-type (second uffi-type)))
(:struct-pointer :pointer))
uffi-type))))
(cffi:define-foreign-type uffi-array-type ()
;; ELEMENT-TYPE should be /unparsed/, suitable for passing to mem-aref.
((element-type :initform (error "An element-type is required.")
:accessor element-type :initarg :element-type)
(nelems :initform (error "nelems is required.")
:accessor nelems :initarg :nelems))
(:actual-type :pointer)
(:documentation "UFFI's :array type."))
(cffi:define-parse-method uffi-array (element-type count)
(make-instance 'uffi-array-type :element-type element-type
:nelems (or count 1)))
(defmethod cffi:foreign-type-size ((type uffi-array-type))
(* (cffi:foreign-type-size (element-type type)) (nelems type)))
(defmethod cffi::aggregatep ((type uffi-array-type))
t)
;; UFFI's :(unsigned-)char
#+#:ignore
(cffi:define-foreign-type uffi-char ()
())
#+#:ignore
(cffi:define-parse-method uffi-char (base-type)
(make-instance 'uffi-char :actual-type base-type))
#+#:ignore
(defmethod cffi:translate-to-foreign ((value character) (type uffi-char))
(char-code value))
#+#:ignore
(defmethod cffi:translate-from-foreign (obj (type uffi-char))
(code-char obj))
(defmacro def-type (name type)
"Define a Common Lisp type NAME for UFFI type TYPE."
(declare (ignore type))
`(deftype ,name () t))
(defmacro def-foreign-type (name type)
"Define a new foreign type."
`(cffi:defctype ,name ,(convert-uffi-type type)))
(defmacro def-constant (name value &key export)
"Define a constant and conditionally export it."
`(eval-when (:compile-toplevel :load-toplevel :execute)
(defconstant ,name ,value)
,@(when export `((export ',name)))
',name))
(defmacro null-char-p (val)
"Return true if character is null."
`(zerop (char-code ,val)))
(defmacro def-enum (enum-name args &key (separator-string "#"))
"Creates a constants for a C type enum list, symbols are
created in the created in the current package. The symbol is the
concatenation of the enum-name name, separator-string, and
field-name"
(let ((counter 0)
(cmds nil)
(constants nil))
(declare (fixnum counter))
(dolist (arg args)
(let ((name (if (listp arg) (car arg) arg))
(value (if (listp arg)
(prog1
(setq counter (cadr arg))
(incf counter))
(prog1
counter
(incf counter)))))
(setq name (intern (concatenate 'string
(symbol-name enum-name)
separator-string
(symbol-name name))))
(push `(def-constant ,name ,value) constants)))
(setf cmds (append '(progn) `((cffi:defctype ,enum-name :int))
(nreverse constants)))
cmds))
(defmacro def-struct (name &body fields)
"Define a C structure."
`(cffi:defcstruct ,name
,@(loop for (name uffi-type) in fields
for cffi-type = (convert-uffi-type uffi-type)
collect (list name cffi-type))))
;; TODO: figure out why the compiler macro is kicking in before
;; the setf expander.
(defun %foreign-slot-value (obj type field)
(cffi:foreign-slot-value obj `(:struct ,type) field))
(defun (setf %foreign-slot-value) (value obj type field)
(setf (cffi:foreign-slot-value obj `(:struct ,type) field) value))
(defmacro get-slot-value (obj type field)
"Access a slot value from a structure."
`(%foreign-slot-value ,obj ,type ,field))
;; UFFI uses a different function when accessing a slot whose
;; type is a pointer. We don't need that in CFFI so we use
;; foreign-slot-value too.
(defmacro get-slot-pointer (obj type field)
"Access a pointer slot value from a structure."
`(cffi:foreign-slot-value ,obj ,type ,field))
(defmacro def-array-pointer (name type)
"Define a foreign array type."
`(cffi:defctype ,name (uffi-array ,(convert-uffi-type type) 1)))
(defmacro deref-array (array type position)
"Dereference an array."
`(cffi:mem-aref ,array
,(if (constantp type)
`',(element-type (cffi::parse-type
(convert-uffi-type (eval type))))
`(element-type (cffi::parse-type
(convert-uffi-type ,type))))
,position))
;; UFFI's documentation on DEF-UNION is a bit scarce, I'm not sure
;; if DEFCUNION and DEF-UNION are strictly compatible.
(defmacro def-union (name &body fields)
"Define a foreign union type."
`(cffi:defcunion ,name
,@(loop for (name uffi-type) in fields
for cffi-type = (convert-uffi-type uffi-type)
collect (list name cffi-type))))
(defun convert-uffi-type-form (type-form)
(if (constantp type-form)
`',(convert-uffi-type (eval type-form))
`(convert-uffi-type ,type-form)))
(defmacro allocate-foreign-object (type &optional (size 1))
"Allocate one or more instance of a foreign type."
`(cffi:foreign-alloc ,(convert-uffi-type-form type)
:count ,size))
(defmacro free-foreign-object (ptr)
"Free a foreign object allocated by ALLOCATE-FOREIGN-OBJECT."
`(cffi:foreign-free ,ptr))
(defmacro with-foreign-object ((var type) &body body)
"Wrap the allocation of a foreign object around BODY."
`(cffi:with-foreign-object (,var ,(convert-uffi-type-form type))
,@body))
;; Taken from UFFI's src/objects.lisp
(defmacro with-foreign-objects (bindings &rest body)
(if bindings
`(with-foreign-object ,(car bindings)
(with-foreign-objects ,(cdr bindings)
,@body))
`(progn ,@body)))
(defmacro size-of-foreign-type (type)
"Return the size in bytes of a foreign type."
`(cffi:foreign-type-size ,(convert-uffi-type-form type)))
(defmacro pointer-address (ptr)
"Return the address of a pointer."
`(cffi:pointer-address ,ptr))
(defmacro deref-pointer (ptr type)
"Dereference a pointer."
`(cffi:mem-ref ,ptr ,(convert-uffi-type-form type)))
(defsetf deref-pointer (ptr type) (value)
`(setf (cffi:mem-ref ,ptr ,(convert-uffi-type-form type)) ,value))
(defmacro ensure-char-character (obj &environment env)
"Convert OBJ to a character if it is an integer."
(if (constantp obj env)
(if (characterp obj) obj (code-char obj))
(let ((obj-var (gensym)))
`(let ((,obj-var ,obj))
(if (characterp ,obj-var)
,obj-var
(code-char ,obj-var))))))
(defmacro ensure-char-integer (obj &environment env)
"Convert OBJ to an integer if it is a character."
(if (constantp obj env)
(let ((the-obj (eval obj)))
(if (characterp the-obj) (char-code the-obj) the-obj))
(let ((obj-var (gensym)))
`(let ((,obj-var ,obj))
(if (characterp ,obj-var)
(char-code ,obj-var)
,obj-var)))))
(defmacro ensure-char-storable (obj)
"Ensure OBJ is storable as a character."
`(ensure-char-integer ,obj))
(defmacro make-null-pointer (type)
"Create a NULL pointer."
(declare (ignore type))
`(cffi:null-pointer))
(defmacro make-pointer (address type)
"Create a pointer to ADDRESS."
(declare (ignore type))
`(cffi:make-pointer ,address))
(defmacro null-pointer-p (ptr)
"Return true if PTR is a null pointer."
`(cffi:null-pointer-p ,ptr))
(defparameter +null-cstring-pointer+ (cffi:null-pointer)
"A constant NULL string pointer.")
(defmacro char-array-to-pointer (obj)
obj)
(defmacro with-cast-pointer ((var ptr type) &body body)
"Cast a pointer, does nothing in CFFI."
(declare (ignore type))
`(let ((,var ,ptr))
,@body))
(defmacro def-foreign-var (name type module)
"Define a symbol macro to access a foreign variable."
(declare (ignore module))
(flet ((lisp-name (name)
(intern (cffi-sys:canonicalize-symbol-name-case
(substitute #\- #\_ name)))))
`(cffi:defcvar ,(if (listp name)
name
(list name (lisp-name name)))
,(convert-uffi-type type))))
(defmacro def-pointer-var (name value &optional doc)
#-openmcl `(defvar ,name ,value ,@(if doc (list doc)))
#+openmcl `(ccl::defloadvar ,name ,value ,doc))
(defmacro convert-from-cstring (s)
"Convert a cstring to a Lisp string."
(let ((ret (gensym)))
`(let ((,ret (cffi:foreign-string-to-lisp ,s)))
(if (equal ,ret "")
nil
,ret))))
(defmacro convert-to-cstring (obj)
"Convert a Lisp string to a cstring."
(let ((str (gensym)))
`(let ((,str ,obj))
(if (null ,str)
(cffi:null-pointer)
(cffi:foreign-string-alloc ,str)))))
(defmacro free-cstring (ptr)
"Free a cstring."
`(cffi:foreign-string-free ,ptr))
(defmacro with-cstring ((foreign-string lisp-string) &body body)
"Binds a newly creating string."
(let ((str (gensym)) (body-proc (gensym)))
`(flet ((,body-proc (,foreign-string) ,@body))
(let ((,str ,lisp-string))
(if (null ,str)
(,body-proc (cffi:null-pointer))
(cffi:with-foreign-string (,foreign-string ,str)
(,body-proc ,foreign-string)))))))
;; Taken from UFFI's src/strings.lisp
(defmacro with-cstrings (bindings &rest body)
(if bindings
`(with-cstring ,(car bindings)
(with-cstrings ,(cdr bindings)
,@body))
`(progn ,@body)))
(defmacro def-function (name args &key module (returning :void))
"Define a foreign function."
(declare (ignore module))
`(cffi:defcfun ,name ,(convert-uffi-type returning)
,@(loop for (name type) in args
collect `(,name ,(convert-uffi-type type)))))
;;; Taken from UFFI's src/libraries.lisp
(defvar *loaded-libraries* nil
"List of foreign libraries loaded. Used to prevent reloading a library")
(defun default-foreign-library-type ()
"Returns string naming default library type for platform"
#+(or win32 cygwin mswindows) "dll"
#+(or macos macosx darwin ccl-5.0) "dylib"
#-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) "so")
(defun foreign-library-types ()
"Returns list of string naming possible library types for platform,
sorted by preference"
#+(or win32 cygwin mswindows) '("dll" "lib" "so")
#+(or macos macosx darwin ccl-5.0) '("dylib" "bundle")
#-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) '("so" "a" "o"))
(defun find-foreign-library (names directories &key types drive-letters)
"Looks for a foreign library. directories can be a single
string or a list of strings of candidate directories. Use default
library type if type is not specified."
(unless types
(setq types (foreign-library-types)))
(unless (listp types)
(setq types (list types)))
(unless (listp names)
(setq names (list names)))
(unless (listp directories)
(setq directories (list directories)))
#+(or win32 mswindows)
(unless (listp drive-letters)
(setq drive-letters (list drive-letters)))
#-(or win32 mswindows)
(setq drive-letters '(nil))
(dolist (drive-letter drive-letters)
(dolist (name names)
(dolist (dir directories)
(dolist (type types)
(let ((path (make-pathname
#+lispworks :host
#+lispworks (when drive-letter drive-letter)
#-lispworks :device
#-lispworks (when drive-letter drive-letter)
:name name
:type type
:directory
(etypecase dir
(pathname
(pathname-directory dir))
(list
dir)
(string
(pathname-directory
(parse-namestring dir)))))))
(when (probe-file path)
(return-from find-foreign-library path)))))))
nil)
(defun convert-supporting-libraries-to-string (libs)
(let (lib-load-list)
(dolist (lib libs)
(push (format nil "-l~A" lib) lib-load-list))
(nreverse lib-load-list)))
(defun load-foreign-library (filename &key module supporting-libraries
force-load)
#+(or allegro mcl sbcl clisp) (declare (ignore module supporting-libraries))
#+(or cmucl scl sbcl) (declare (ignore module))
(when (and filename (or (null (pathname-directory filename))
(probe-file filename)))
(if (pathnamep filename) ;; ensure filename is a string to check if
(setq filename (namestring filename))) ; already loaded
(if (and (not force-load)
(find filename *loaded-libraries* :test #'string-equal))
t ;; return T, but don't reload library
(progn
;; FIXME: Hmm, what are these two for?
#+cmucl
(let ((type (pathname-type (parse-namestring filename))))
(if (string-equal type "so")
(sys::load-object-file filename)
(alien:load-foreign filename
:libraries
(convert-supporting-libraries-to-string
supporting-libraries))))
#+scl
(let ((type (pathname-type (parse-namestring filename))))
(if (string-equal type "so")
(sys::load-dynamic-object filename)
(alien:load-foreign filename
:libraries
(convert-supporting-libraries-to-string
supporting-libraries))))
#-(or cmucl scl)
(cffi:load-foreign-library filename)
(push filename *loaded-libraries*)
t))))
;; Taken from UFFI's src/os.lisp
(defun getenv (var)
"Return the value of the environment variable."
#+allegro (sys::getenv (string var))
#+clisp (sys::getenv (string var))
#+(or cmucl scl) (cdr (assoc (string var) ext:*environment-list* :test #'equalp
:key #'string))
#+(or ecl gcl) (si:getenv (string var))
#+lispworks (lw:environment-variable (string var))
#+lucid (lcl:environment-variable (string var))
#+(or mcl ccl) (ccl::getenv var)
#+sbcl (sb-ext:posix-getenv var)
#-(or allegro clisp cmucl ecl scl gcl lispworks lucid mcl ccl sbcl)
(error 'not-implemented :proc (list 'getenv var)))
;; Taken from UFFI's src/os.lisp
;; modified from function ASDF -- Copyright Dan Barlow and Contributors
(defun run-shell-command (control-string &rest args)
"Interpolate ARGS into CONTROL-STRING as if by FORMAT, and
synchronously execute the result using a Bourne-compatible shell, with
output to *trace-output*. Returns the shell's exit code."
(let ((command (apply #'format nil control-string args))
(output *trace-output*))
#+sbcl
(sb-impl::process-exit-code
(sb-ext:run-program
"/bin/sh"
(list "-c" command)
:input nil :output output))
#+(or cmucl scl)
(ext:process-exit-code
(ext:run-program
"/bin/sh"
(list "-c" command)
:input nil :output output))
#+allegro
(excl:run-shell-command command :input nil :output output)
#+lispworks
(system:call-system-showing-output
command
:shell-type "/bin/sh"
:output-stream output)
#+clisp ;XXX not exactly *trace-output*, I know
(ext:run-shell-command command :output :terminal :wait t)
#+openmcl
(nth-value 1
(ccl:external-process-status
(ccl:run-program "/bin/sh" (list "-c" command)
:input nil :output output
:wait t)))
#+ecl
(nth-value 1
(ext:run-program
"/bin/sh" (list "-c" command)
:input nil :output output :error nil :wait t))
#-(or openmcl ecl clisp lispworks allegro scl cmucl sbcl)
(error "RUN-SHELL-PROGRAM not implemented for this Lisp")
))
;;; Some undocumented UFFI operators...
(defmacro convert-from-foreign-string
(obj &key length (locale :default)
(encoding 'cffi:*default-foreign-encoding*)
(null-terminated-p t))
;; in effect, (eq NULL-TERMINATED-P (null LENGTH)). Hopefully,
;; that's compatible with the intended semantics, which are
;; undocumented. If that's not the case, we can implement
;; NULL-TERMINATED-P in CFFI:FOREIGN-STRING-TO-LISP.
(declare (ignore locale null-terminated-p))
(let ((ret (gensym)))
`(let ((,ret (cffi:foreign-string-to-lisp ,obj
:count ,length
:encoding ,encoding)))
(if (equal ,ret "")
nil
,ret))))
;; What's the difference between this and convert-to-cstring?
(defmacro convert-to-foreign-string
(obj &optional (encoding 'cffi:*default-foreign-encoding*))
(let ((str (gensym)))
`(let ((,str ,obj))
(if (null ,str)
(cffi:null-pointer)
(cffi:foreign-string-alloc ,str :encoding ,encoding)))))
(defmacro allocate-foreign-string (size &key unsigned)
(declare (ignore unsigned))
`(cffi:foreign-alloc :char :count ,size))
;; Ditto.
(defmacro with-foreign-string ((foreign-string lisp-string) &body body)
(let ((str (gensym)))
`(let ((,str ,lisp-string))
(if (null ,str)
(let ((,foreign-string (cffi:null-pointer)))
,@body)
(cffi:with-foreign-string (,foreign-string ,str)
,@body)))))
(defmacro with-foreign-strings (bindings &body body)
`(with-foreign-string ,(car bindings)
,@(if (cdr bindings)
`((with-foreign-strings ,(cdr bindings) ,@body))
body)))
;; This function returns a form? Where is this used in user-code?
(defun foreign-string-length (foreign-string)
(declare (ignore foreign-string))
(error "FOREIGN-STRING-LENGTH not implemented."))
;; This should be optimized.
(defun convert-from-foreign-usb8 (s len)
(let ((a (make-array len :element-type '(unsigned-byte 8))))
(dotimes (i len a)
(setf (aref a i) (cffi:mem-ref s :unsigned-char i)))))
;;;; String Encodings
(defmacro string-to-octets (str &key encoding null-terminate)
`(babel:concatenate-strings-to-octets
(or ,encoding cffi:*default-foreign-encoding*)
,str
(if ,null-terminate
#.(string #\Nul)
"")))
(defmacro octets-to-string (octets &key encoding)
`(babel:octets-to-string ,octets
:encoding (or ,encoding
cffi:*default-foreign-encoding*)))
(defun foreign-encoded-octet-count (str &key encoding)
(babel:string-size-in-octets str
:encoding (or encoding
cffi:*default-foreign-encoding*)))
| 22,715 | Common Lisp | .lisp | 577 | 32.636049 | 81 | 0.636566 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 61f6ae905ea9261de31fad7103a804c3df7e0add13f6cb3ac4eedb0a0525bd36 | 43,019 | [
370619
] |
43,020 | test-cl-json.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/test-cl-json.lisp | (defpackage testing-cl-json
(:use common-lisp))
(in-package :testing-cl-json)
(require :asdf)
(asdf:initialize-source-registry '(:source-registry (:directory :here)
:inherit-configuration))
(defun leave-lisp (message return)
(fresh-line *error-output*)
(when message
(format *error-output* message)
(terpri *error-output*))
(finish-output *error-output*)
(finish-output *standard-output*)
(uiop:quit return))
(defmacro quit-on-error (&body body)
`(call-quitting-on-error (lambda () ,@body)))
(defun call-quitting-on-error (thunk)
"Unless the environment variable DEBUG_CL_JSON_TEST
is bound, write a message and exit on an error. If
*asdf-test-debug* is true, enter the debugger."
(flet ((quit (c desc)
(format *error-output* "~&Encountered ~a during test.~%~a~%" desc c)
(cond
;; decline to handle the error.
((ignore-errors (funcall (find-symbol "GETENV" :asdf) "DEBUG_CL_JSON_TEST"))
(format t "~&Interactive mode (DEBUG_CL_JSON_TEST) -- Invoke debugger.~%")
(invoke-debugger c))
(t
(finish-output *standard-output*)
(finish-output *trace-output*)
(format *error-output* "~&ABORTING:~% ~S~%" c)
(uiop:print-condition-backtrace c)
(format *error-output* "~&ABORTING:~% ~S~%" c)
(finish-output *error-output*)
(leave-lisp "~&Script failed~%" 1)))))
(handler-bind
((error (lambda (c)
(quit c "ERROR")))
(storage-condition
(lambda (c) (quit c "STORAGE-CONDITION")))
(serious-condition (lambda (c)
(quit c "Other SERIOUS-CONDIITON"))))
(funcall thunk)
(format t "~&Script succeeded~%")
t)))
(quit-on-error
(format t "~&;;; Testing CL-JSON on ~a.~%" (lisp-implementation-type))
(asdf:test-system "cl-json"))
(uiop:quit 0)
| 1,975 | Common Lisp | .lisp | 49 | 32.081633 | 88 | 0.591762 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 970671e03ab740997c00b6bb294101d07ea3da7f08e6eab69100a06eb3b742bb | 43,020 | [
212685
] |
43,021 | compile-cl-json.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/compile-cl-json.lisp | (defpackage compile-cl-json
(:use :common-lisp))
(in-package :compile-cl-json)
(require :asdf)
(asdf:initialize-source-registry '(:source-registry (:directory :here)
:inherit-configuration))
(declaim (optimize (speed 3) (space 3)))
(defun leave-lisp (message return)
(fresh-line *error-output*)
(when message
(format *error-output* message)
(terpri *error-output*))
(finish-output *error-output*)
(finish-output *standard-output*)
(uiop:quit return))
(defmacro quit-on-error (&body body)
`(call-quitting-on-error (lambda () ,@body)))
(defun call-quitting-on-error (thunk)
"Unless the environment variable DEBUG_CL_JSON_TEST
is bound, write a message and exit on an error. If
*asdf-test-debug* is true, enter the debugger."
(handler-bind
((error (lambda (c)
(format *error-output* "~&~a~&" c)
(cond
((ignore-errors (funcall (find-symbol "GETENV" :asdf) "DEBUG_CL_JSON_TEST"))
(break))
(t
(finish-output *standard-output*)
(finish-output *trace-output*)
(format *error-output* "~&ABORTING:~% ~S~%" c)
#+sbcl (sb-debug:backtrace 69)
#+clozure (ccl:print-call-history :count 69 :start-frame-number 1)
#+clisp (system::print-backtrace)
(format *error-output* "~&ABORTING:~% ~S~%" c)
(finish-output *error-output*)
(leave-lisp "~&Script failed~%" 1))))))
(funcall thunk)
(leave-lisp "~&Script succeeded~%" 0)))
(quit-on-error
(ql:quickload "fiveam")
(asdf:compile-system "cl-json"))
| 1,726 | Common Lisp | .lisp | 42 | 31.809524 | 94 | 0.58159 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c646104efa248ab451004c2aa809219356b890c2d7a81d6f0639f1fbc9a48e74 | 43,021 | [
44282
] |
43,022 | package.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/package.lisp | ;;;; -*- Mode: LISP; Base: 10; Syntax: ANSI-Common-lisp; Package: CL-USER -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(defpackage :json
(:nicknames :cl-json)
(:use :common-lisp)
(:export
;; common.lisp
#:with-shadowed-custom-vars
#:bind-custom-vars
#:set-custom-vars
#:*use-strict-json-rules*
#:*json-symbols-package*
#:json-intern
#:unknown-symbol-error
#:safe-json-intern
#:*json-identifier-name-to-lisp*
#:*lisp-identifier-name-to-json*
#:*identifier-name-to-key*
;; camel-case.lisp
#:simplified-camel-case-to-lisp
#:camel-case-to-lisp
#:lisp-to-camel-case
;; objects.lisp
#:with-local-class-registry
#:clear-class-registry
#:fluid-class
#:fluid-object
#:make-object
#:make-object-prototype
#:prototype
#:*prototype-name*
;; decoder.lisp
#:*json-input*
#:decode-json
#:decode-json-strict
#:decode-json-from-string
#:decode-json-from-source
#:json-syntax-error
#:no-char-for-code
#:substitute-char
#:pass-code
#:bignumber-string
#:rational-approximation
#:placeholder
#:*boolean-handler*
#:*integer-handler*
#:*real-handler*
#:*beginning-of-array-handler*
#:*array-member-handler*
#:*end-of-array-handler*
#:*beginning-of-string-handler*
#:*string-char-handler*
#:*end-of-string-handler*
#:*beginning-of-object-handler*
#:*object-key-handler*
#:*object-value-handler*
#:*end-of-object-handler*
#:*json-array-type*
#:*internal-decoder*
#:*array-scope-variables*
#:*object-scope-variables*
#:*string-scope-variables*
#:*aggregate-scope-variables*
#:current-decoder
#:custom-decoder
#:with-custom-decoder-level
#:set-decoder-simple-list-semantics
#:with-decoder-simple-list-semantics
#:set-decoder-simple-clos-semantics
#:with-decoder-simple-clos-semantics
;; encoder.lisp
#:*json-output*
#:unencodable-value-error
#:substitute-printed-representation
#:with-substitute-printed-representation-restart
#:encode-json
#:encode-json-to-string
#:encode-json-alist
#:encode-json-alist-to-string
#:encode-json-plist
#:encode-json-plist-to-string
#:with-array
#:as-array-member
#:encode-array-member
#:stream-array-member-encoder
#:with-object
#:as-object-member
#:encode-object-member
#:stream-object-member-encoder
#:use-explicit-encoder
#:use-guessing-encoder
#:with-explicit-encoder
#:with-guessing-encoder
#:json-bool
#:json-or-null
;; utils.lisp
#:json-bind
)
#+cl-json-clos
(:import-from #+(or mcl openmcl) #:ccl
#+cmu #:clos-mop
#+sbcl #:sb-mop
#+(or clisp ecl scl lispworks) #:clos
#+(or allegro abcl) #:mop
#+genera #:clos-internals
#:class-slots
#:class-direct-slots
#:class-direct-superclasses
#:slot-definition-name
#:add-direct-subclass
#:remove-direct-subclass
#:validate-superclass
#:class-precedence-list
#:compute-class-precedence-list
#:ensure-class
#:finalize-inheritance
))
(defpackage :json-rpc
(:use :common-lisp :json)
(:shadow #:defconstant)
(:export
#:clear-exported
#:export-as-json-rpc
;; invoke functions for the benefit of JSON-RPC
#:invoke-rpc
#:invoke-rpc-parsed
;; restarts
#:send-error
#:send-error-object
#:send-nothing
#:send-internal-error
;; special variable for controlling JSON-RPC
#:*json-rpc-version*
;; constants
#:+json-rpc-1.1+
#:+json-rpc-2.0+
;; condition
#:json-rpc-call-error
;; declarations
#:def-json-rpc-encoding
#:defun-json-rpc
))
| 3,766 | Common Lisp | .lisp | 144 | 21.673611 | 77 | 0.662791 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | b4895ac19a2dc412ae1901ae58e7f2b50bf8760628ed6b309b60bda0c89aeb6c | 43,022 | [
400896
] |
43,023 | json-rpc.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/json-rpc.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10 ; Package: JSON-RPC -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; Modifications copyright (c) 2009 by Robert P. Goldman and SIFT, LLC.
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json-rpc)
;; http://json-rpc.org/wiki/specification
;; http://json-rpc.org/wd/JSON-RPC-1-1-WD-20060807.html
;;;---------------------------------------------------------------------------
;;; I have added support for a partial implementation of the JSON RPC 2.0
;;; draft specification. The implementation is partial because:
;;; 1. There is no support for batch/multicall and
;;; 2. There is no support for positional arguments which, in JSON RPC 2.0,
;;; are handled by passing a singleton object as the params, rather than
;;; passing a parameter array.
;;; [2010/01/03:rpg]
;;;---------------------------------------------------------------------------
;;; this version is similar to the one in the SBCL manual, but allows you to
;;; override previous values. The one in the SBCL manual quietly throws new
;;; values on the floor, AFAICT. [2010/01/09:rpg]
(defmacro defconstant (name value &optional doc)
`(cl:defconstant ,name (if (and (boundp ',name)
(equalp (symbol-value ',name)
,value))
(symbol-value ',name) ,value)
,@(when doc (list doc))))
(defconstant +json-rpc-1.1+ "1.1")
(defconstant +json-rpc-2.0+ "2.0")
(defvar *json-rpc-version* +json-rpc-1.1+
"Bind this variable to influence whether you want to use
JSON-RPC version 1.1 or 2.0.")
(defvar *json-rpc-functions* (make-hash-table :test #'equal))
(defun clear-exported ()
(clrhash *json-rpc-functions*))
(defmacro defun-json-rpc (name type lambda-list &body body)
"Defines a function and registers it as a json-rpc target."
(unless (json-rpc-encoding-p type)
(error "New version of defun-json-rpc requires a TYPE argument"))
`(progn
(defun ,name ,lambda-list ,@body)
(export-as-json-rpc ',name (lisp-to-camel-case (symbol-name ',name))
,type)))
(defgeneric json-rpc-encoding-p (keyword)
(:documentation "Is KEYWORD a valid JSON-RPC value encoding?")
(:method (keyword)
"Default is no."
(declare (ignore keyword))
nil)
;;; built-in methods
(:method ((keyword (eql :guessing)))
t)
(:method ((keyword (eql :streaming)))
t)
(:method ((keyword (eql :explicit)))
t))
(defgeneric encode-json-rpc-value (raw-value encoding)
(:documentation "Translate RAW-VALUE according to JSON-RPC
value encoding ENCODING")
(:method :before (raw-value encoding)
(declare (ignore raw-value))
(unless (json-rpc-encoding-p encoding)
(error "Invalid JSON-RPC encoding spec: ~a" encoding)))
(:method (raw-value (encoding (eql :guessing)))
(list :json
(with-guessing-encoder
(encode-json-to-string raw-value))))
(:method (raw-value (encoding (eql :streaming)))
(if (stringp raw-value)
(list :json raw-value)
(error "Can't stream non-string return value ~a" raw-value)))
(:method (raw-value (encoding (eql :explicit)))
raw-value))
(defmacro def-json-rpc-encoding (keyword (var) &rest body)
"Define a new encoding keyword, KEYWORD. When the encoding
is invoked, the raw value will be bound to VAR, and the
BODY should return the encoded value."
`(progn
(defmethod json-rpc-encoding-p ((keyword (eql ',keyword)))
t)
(defmethod encode-json-rpc-value (,var (keyword (eql ',keyword)))
,@body)))
(def-json-rpc-encoding :boolean (raw-val)
(list :json
(with-explicit-encoder
(encode-json-to-string (if raw-val '(:true) '(:false))))))
(defconstant +empty-array+ '(:array))
(def-json-rpc-encoding :array (raw-val)
(list :json
(with-explicit-encoder
(encode-json-to-string
(cond ((null raw-val) +empty-array+)
((listp raw-val)
(cons :array raw-val))
((arrayp raw-val)
raw-val)
(t (error "don't know how to encode value ~a as array." raw-val)))))))
(defun export-as-json-rpc (func function-name &optional type)
"Registers a lambda function FUNC as a json-rpc function.
TYPE determines how the return value of FUNC should be interpreted:
:explicit using the explicit encoder syntax,
:guessing using the guessing encode syntax
:streaming as a raw JSON string.
"
(setf (gethash function-name *json-rpc-functions*) (cons func (or type :guessing))))
(defun make-rpc-response (&key result error id)
"When the method invocation completes, the service must reply with a response. The response is a single object serialized using JSON.
It has three properties:
* result - The Object that was returned by the invoked method. This must be null in case there was an error invoking the method.
* error - An Error object(unspecified in json-rpc 1.0) if there was an error invoking the method. Null if there was no error.
* id - This must be the same id as the request it is responding to. "
(cond ((equalp *json-rpc-version* +json-rpc-1.1+)
(with-explicit-encoder
(json:encode-json-to-string
`(:object
(:result . ,result)
(:error . ,error)
(:id . ,id)))))
((equalp *json-rpc-version* +json-rpc-2.0+)
(cond (result
(when error
(error "Forbidden to have both a JSON-RPC result AND a JSON-RPC error."))
(with-explicit-encoder
(json:encode-json-to-string
`(:object
(:jsonrpc . ,+json-rpc-2.0+)
(:result . ,result)
(:id . ,id)))))
(error
(let ((error (cdr error)))
;; check the slots
(unless (and (assoc :code error)
(integerp (cdr (assoc :code error)))
(assoc :message error)
(stringp (cdr (assoc :message error))))
(cerror "Just return it anyway."
"Ill-formed JSON-RPC error, ~a, for version ~a"
error *json-rpc-version*)))
(with-explicit-encoder
(json:encode-json-to-string
`(:object
(:jsonrpc . ,+json-rpc-2.0+)
(:error . ,error)
(:id . ,id)))))
(t
(error "Response must have either result or error."))))
(t (error "Unknown JSON-RPC protocol version ~a." *json-rpc-version*))))
(defun make-json-rpc-error-object-1.1 (message &key code error-object)
"This code is based on the Working Draft 7 August 2006 of Json-rpc 1.1 specification.
http://json-rpc.org/wd/JSON-RPC-1-1-WD-20060807.html
"
(let ((eo `(:object
(:name . "JSONRPCError")
(:code . ,(or code 999))
(:message . ,message))))
(if error-object
(append eo `((:error . ,error-object)))
eo)))
(defun make-json-rpc-error-object-2.0 (&key message code data error-object)
(unless (stringp message)
(error "Message attribute of JSON-RPC object must be a string."))
;; symbolic error codes:
;;-32700 Parse error. Invalid JSON. An error occurred on the server while parsing the JSON text.
;;-32600 Invalid Request. The received JSON is not a valid JSON-RPC Request.
;;-32601 Method not found. The requested remote-procedure does not exist / is not available.
;;-32602 Invalid params. Invalid method parameters.
;;-32603 Internal error. Internal JSON-RPC error.
;;-32099..-32000 Server error. Reserved for implementation-defined server-errors.
(if (symbolp code)
(setf code
(ecase code
(:parse-error -32700)
(:invalid-request -32600)
(:method-not-found -32601)
(:invalid-params -32602)
(:internal-error -32603)
(:service-error -32000)))
(unless (integerp code)
(error "Code attribute of JSON-RPC object must be an integer.")))
(let (data-obj)
(when error-object
(push `(:error . ,error-object) data-obj))
(when data
(push `(:data ,data) data-obj))
(let ((eo `(:object
(:name . "JSONRPCError")
(:code . ,code)
(:message . ,message)
,@(when data-obj
`((:data . (:object ,@data-obj)))))))
eo)))
(defun invoke-rpc (json-source)
"A remote method is invoked by sending a request to a remote service. The request is a single object serialized using JSON.
It has three properties:
* method - A String containing the name of the method to be invoked.
* params - An Array of objects to pass as arguments to the method.
* id - The request id. This can be of any type. It is used to match the response with the request that it is replying to. "
(json-bind (method params id) json-source
(invoke-rpc-parsed method params id)))
(define-condition json-rpc-call-error (error)
((encapsulated-error
:initarg :error
:reader encapsulated-error
)))
;;; FIXME: I discovered that if the METHOD argument is NIL, this just does nothing. Not sure why... [2010/01/15:rpg]
(defun invoke-rpc-parsed (method params &optional id)
(flet ((json-rpc-2.0 ()
(equalp *json-rpc-version* +json-rpc-2.0+)))
(restart-case
(let ((func-type (gethash method *json-rpc-functions*)))
(if func-type
(handler-bind
((error #'(lambda (err)
(error 'json-rpc-call-error :error err))))
(destructuring-bind (func . type) func-type
(let ((retval (restart-case (apply func params)
(use-value (value)
value)))
explicit-retval)
(when id
;; if there's no id, this is a notification, and no response should be sent
;; [2009/12/30:rpg]
(setf explicit-retval
(encode-json-rpc-value retval type)))
(make-rpc-response :id id :result explicit-retval))))
(when id
(make-rpc-response :id id :error (cond ((json-rpc-2.0)
(make-json-rpc-error-object-2.0
:message (format nil "Procedure ~a not found." method)
:code :method-not-found))
(t
(make-json-rpc-error-object-1.1
(format nil "Procedure ~a not found." method))))))))
(send-error (message &optional code error-object)
:test (lambda (c) (declare (ignore c)) id)
(make-rpc-response :id id
:error
(if (json-rpc-2.0)
(progn
(unless code
(assert code (code)
"Error code is mandatory in JSON-RPC version 2.0."))
(if error-object
(make-json-rpc-error-object-2.0
:message message
:code code
:error-object error-object)
(make-json-rpc-error-object-2.0
:message message
:code code)))
(make-json-rpc-error-object-1.1 message
:code code
:error-object error-object))))
(send-error-object (error-object)
:test (lambda (c) (declare (ignore c)) id)
(make-rpc-response :id id :error error-object))
(send-nothing ()
nil)
(send-internal-error ()
:test (lambda (c) (declare (ignore c)) id)
(format t "~&invoking send-internal-error restart.~%")
(make-rpc-response :id id
:error
(if (json-rpc-2.0)
(make-json-rpc-error-object-2.0
:message "Service error"
:code :service-error)
(make-json-rpc-error-object-1.1 "Service error")))))))
(defmacro def-restart (restart-name &rest (params))
`(defun ,restart-name (,@params &optional condition)
(let ((restart (find-restart ',restart-name condition)))
(invoke-restart restart ,@params))))
(def-restart send-error (errmsg code))
(def-restart send-error-object (explicit-errobject))
(def-restart send-nothing ())
(def-restart send-internal-error ())
;;;; This is a fragment of how to generate a smd description
;;;; If someone is interested you might want to clean this
;;;; up and incorporated this into json-rpc
;;;;
;;;; (defmacro defun-schat-api (name params &body body)
;;;; .....
;;;; (setf (gethash ',name *json-rpc-method-definitions*)
;;;; (list :parameters params))
;;;;
;;;; (defun generate-smd (stream service-url)
;;;; (let ((json-data
;;;; `(:object
;;;; :service-type "JSON-RPC"
;;;; :service-+url+ ,service-url
;;;; :methods
;;;; (:list
;;;; ,@(loop for fname being each hash-key of *json-rpc-method-definitions*
;;;; using (hash-value description)
;;;; for params = (getf description :parameters)
;;;; collect `(:object
;;;; :name ,fname
;;;; :parameters (:list
;;;; ,@(loop for param in params
;;;; collect `(:object :name ,param)))))))))
;;;; (json:with-explicit-encoder
;;;; (json:encode-json json-data stream))))
;;;;
;;;; (defun generate-smd-file (filename)
;;;; (with-open-file (s filename :direction :output :if-exists :supersede)
;;;; (generate-smd s "/schat/json-rpc")))
;;;;
| 14,959 | Common Lisp | .lisp | 306 | 37.545752 | 135 | 0.537962 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 0a284597469207db91e0b66ad188a9fc68bbf2a668b566cd09d5a076a3065c98 | 43,023 | [
56753
] |
43,024 | objects.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/objects.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
(defvar *class-registry* nil
"A list of anonymous fluid classes, one member for every distinct
combination of direct superclasses.")
(defmacro with-local-class-registry ((&key inherit) &body body)
"Run BODY in a dynamic environment where *CLASS-REGISTRY* is a
temporary local list. If :INHERIT is non-null, the local registry
shall initially have the same content as the exterior *CLASS-REGISTRY*,
otherwise it shall be NIL."
`(let ((*class-registry*
,(if inherit
`(copy-alist
,(if (eql inherit t) '*class-registry* inherit)))))
,@body))
(defun clear-class-registry ()
"Reset the *CLASS-REGISTRY* to NIL."
(setq *class-registry* nil))
(defun find-class* (class-designator)
"Like FIND-CLASS, but allow self-designating classes for the
argument, and assert that the resulting class is a STANDARD-CLASS."
(let ((class
(if (typep class-designator 'class)
class-designator
(or (find-class class-designator nil)
(error 'cell-error :name 'class-designator)))))
(check-type class standard-class)
class))
(eval-when (:load-toplevel :compile-toplevel :execute)
(defclass fluid-class (standard-class) ()
(:documentation "A class to whose instances arbitrary new slots may
be added on the fly.")))
(defmethod add-direct-subclass ((superclass class)
(subclass fluid-class))
"Fluid classes are thought to be anonymous, and so should not be
registered in the superclass."
(declare (ignore superclass subclass))
(values))
(defmethod remove-direct-subclass ((superclass class)
(subclass fluid-class))
"Fluid classes are thought to be anonymous, and so should not be
registered in the superclass."
(declare (ignore superclass subclass))
(values))
(eval-when (:compile-toplevel :load-toplevel :execute)
(defmethod validate-superclass ((class fluid-class)
(superclass standard-class))
"Any fluid class is also a standard class."
t))
(eval-when (:compile-toplevel :load-toplevel :execute)
(defclass fluid-object (standard-object) ()
(:documentation "Any instance of a fluid class.")
(:metaclass fluid-class)))
(defmethod compute-class-precedence-list ((class fluid-class))
"Objects of fluid classes are fluid objects."
(loop for c in (call-next-method)
with standard = (find-class 'standard-object)
and fluid = (find-class 'fluid-object)
if (eq c fluid) do (setq fluid nil)
else if (and (eq c standard) fluid) collect fluid
collect c))
(defmethod slot-missing ((class fluid-class) (object fluid-object) name
(op (eql 'slot-boundp)) &optional new-value)
"A missing slot in a fluid class is considered unbound."
(declare (ignore class object name op new-value))
nil)
(defmethod slot-missing ((class fluid-class) (object fluid-object) name
(op (eql 'slot-makunbound)) &optional new-value)
"A missing slot in a fluid class is considered unbound."
(declare (ignore class name op new-value))
object)
(defmethod slot-missing ((class fluid-class) (object fluid-object) name
(op (eql 'slot-value)) &optional new-value)
"On attempting to get the value of a missing slot, raise a
slot-unbound error."
(declare (ignore op new-value))
(slot-unbound class object name))
(defmethod slot-missing ((class fluid-class) (object fluid-object) name
(op (eql 'setf)) &optional new-value)
"On attempting to set a missing slot, add the slot to the class,
then repeat SETF."
(reinitialize-instance class
:direct-superclasses
(class-direct-superclasses class)
:direct-slots
(let ((extant-slots (class-direct-slots class)))
(if (null extant-slots)
`((:name ,name))
(loop for slots on extant-slots
for slot-name = (slot-definition-name (car slots))
if (endp (cdr slots))
collect `(:name ,slot-name)
and collect `(:name ,name)
else
collect `(:name ,slot-name)))))
(make-instances-obsolete class)
(setf (slot-value object name) new-value))
(defun ensure-fluid-class-with-slots (slots superclasses
&optional extant-class)
"Create or update a fluid class, ensuring that it has (at least) all
the given SLOTS and SUPERCLASSES."
(flet ((extant-slot-p (name)
(lambda (class)
(loop for slot in (class-slots class)
thereis (eq (slot-definition-name slot) name))))
(slot-init (name) `(:name ,name)))
(if extant-class
(let* ((extant-superclasses
(class-direct-superclasses extant-class))
(new-superclasses
(remove-if (lambda (class)
(find class extant-superclasses))
superclasses))
(extant-slots
(mapcar #'slot-definition-name
(class-direct-slots extant-class)))
(new-slots
(remove-if (lambda (name)
(let ((containing (extant-slot-p name)))
(or (funcall containing extant-class)
(some containing superclasses))))
slots)))
(if (or new-superclasses new-slots)
(make-instances-obsolete
(reinitialize-instance extant-class
:direct-superclasses
(append extant-superclasses new-superclasses)
:direct-slots
(mapcar #'slot-init (nconc extant-slots new-slots)))))
extant-class)
(make-instance 'fluid-class
;; CMUCL's PCL implementation tries to perform (SETF
;; KERNEL::FIND-CLASS) on dynamically created fluid classes
;; which leads to an error if the class has a NIL name.
:name #-cmu nil #+cmu (gensym "FLUID")
:direct-superclasses superclasses
:direct-slots
(loop for slot in slots
unless (some (extant-slot-p slot) superclasses)
collect (slot-init slot))))))
(defun make-and-populate-instance (class bindings)
"Make an instance of the given CLASS, and set its slots to given
values. BINDINGS must be a list of pairs whose CARs are slot names
and CDRs are the respective values. If no slot of a given name is
defined in the CLASS, the corresponding value is discarded."
(let ((object (make-instance class)))
(if (typep class 'fluid-class)
(loop for slot in (class-direct-slots class)
for slot-name = (slot-definition-name slot)
if (and (slot-boundp object slot-name)
(null (slot-value object slot-name)))
do (slot-makunbound object slot-name)))
(loop for (slot . value) in bindings
if (slot-exists-p object slot)
do (setf (slot-value object slot) value))
object))
(defgeneric make-object (bindings class &optional superclasses)
(:documentation "If CLASS is not NIL, create an instance of that
class. Otherwise, create a fluid object whose class has the given
SUPERCLASSES (null list by default). In either case, populate the
resulting object using BINDINGS (an alist of slot names and
values)."))
(defmethod make-object (bindings (class (eql nil))
&optional (superclasses nil))
"Create a FLUID-OBJECT with the slots given by BINDINGS and whose
class has all the given SUPERCLASSES. If the current *CLASS-REGISTRY*
has a member with exactly the same direct superclasses, it is updated
to include all the given slots. Otherwise, a new FLUID-CLASS is
allocated and added to the *CLASS-REGISTRY*."
(let* ((superclasses
(mapcar #'find-class*
(if (find-if (lambda (c) (subtypep c 'fluid-object))
superclasses)
superclasses
(append superclasses (list 'fluid-object)))))
(extant-class-etc
(member superclasses *class-registry*
:test #'equal :key #'class-direct-superclasses))
(extant-class (car extant-class-etc))
(updated-class
(ensure-fluid-class-with-slots
(mapcar #'car bindings) superclasses extant-class)))
(if extant-class
(if (not (eq extant-class updated-class))
(setf (car extant-class-etc) updated-class))
(push updated-class *class-registry*))
(make-and-populate-instance updated-class bindings)))
(defmethod make-object (bindings class &optional superclasses)
"If the CLASS is explicitly specified, just create and populate an
instance, discarding any of the BINDINGS which do not correspond to
the slots of that CLASS."
(declare (ignore superclasses))
(let ((class (find-class* class)))
(make-and-populate-instance class bindings)))
(defmethod make-object (bindings (class (eql (find-class 'cons)))
&optional superclasses)
"If the CLASS is given as 'CONS, return the BINDINGS as alist."
(declare (ignore superclasses))
(copy-seq bindings))
(defmethod make-object (bindings (class (eql (find-class 'list)))
&optional superclasses)
"If the CLASS is given as 'LIST, return the BINDINGS as plist."
(declare (ignore superclasses))
(loop for (key . value) in bindings
collect key collect value))
(defmethod make-object (bindings (class (eql (find-class 'hash-table)))
&optional superclasses)
"If the CLASS is given as 'HASH-TABLE, return the BINDINGS as hash
table."
(declare (ignore superclasses))
(let ((table (make-hash-table :test #'equal)))
(loop for (key . value) in bindings
do (setf (gethash key table) value))
table))
(defmethod make-object (bindings (class symbol) &optional superclasses)
"If the CLASS is given as a symbol, find it and resort to the usual
procedure."
(declare (ignore superclasses))
(make-object bindings (find-class class)))
(defun max-package (symbols &key ((:initial-value package)
(find-package '#:common-lisp)))
"Try to find a package P such that the names of the given SYMBOLS,
when interned in P, yield the same symbols. If no such package
exists, return an unspecific value and issue a warning."
(labels ((symbol-in-package-p (symbol)
(eq (find-symbol (symbol-name symbol) package) symbol))
(update-package-for-symbol (symbol)
(if (not (symbol-in-package-p symbol))
(setq package (symbol-package symbol))))
(check-symbol (symbol)
(if (not (symbol-in-package-p symbol))
(warn "Symbol ~S cannot be found in apparent package ~S."
symbol package))))
(mapc #'update-package-for-symbol symbols)
(mapc #'check-symbol symbols)
package))
(defun package-name* (package)
"Same as PACKAGE-NAME, but ensure that the result is a symbol."
(let ((name (package-name package)))
(if (stringp name) (make-symbol name) name)))
(defvar *prototype-name* 'prototype
"The key of the prototype field in a JSON Object, and the name of a
slot in a Lisp object which accepts its prototype.")
(defclass prototype ()
((lisp-class :initarg :lisp-class :reader lisp-class)
(lisp-superclasses :initarg :lisp-superclasses :reader lisp-superclasses)
(lisp-package :initarg :lisp-package :reader lisp-package))
(:default-initargs :lisp-class nil :lisp-superclasses nil
:lisp-package nil)
(:documentation "A PROTOTYPE contains metadata for an object's class
in a format easily serializable to JSON: either the name of the class
as a string or (if it is anonymous) the names of the superclasses as a
list of strings; and the name of the Lisp package into which the names
of the class's slots and the name of the class / superclasses are to
be interned."))
(defmethod make-load-form ((prototype prototype) &optional environment)
(declare (ignore environment))
`(make-instance 'prototype
,@(if (slot-boundp prototype 'lisp-class)
`(:lisp-class ,(lisp-class prototype)))
,@(if (slot-boundp prototype 'lisp-superclasses)
`(:lisp-superclasses ,(lisp-superclasses prototype)))
,@(if (slot-boundp prototype 'lisp-package)
`(:lisp-package ,(lisp-package prototype)))))
(defgeneric make-object-prototype (object &optional slot-names)
(:documentation "Return a PROTOTYPE describing the OBJECT's class or
superclasses, and the package into which the names of the class /
superclasses and of the OBJECT's slots are to be interned."))
(defmethod make-object-prototype (object &optional slot-names)
"Return a PROTOTYPE describing the OBJECT's class or superclasses,
and the package into which the names of the class / superclasses and
of the OBJECT's slots are to be interned."
(let* ((class (class-of object))
(class-name (if class (class-name class)))
(superclass-names
(if (not class-name)
(set-difference
(mapcar #'class-name (class-direct-superclasses class))
'(standard-object fluid-object))))
(package
(max-package (append superclass-names slot-names)
:initial-value (if class-name
(symbol-package class-name)
(find-package '#:common-lisp)))))
(make-instance 'prototype
:lisp-class class-name
:lisp-superclasses superclass-names
:lisp-package (package-name* package))))
(defmethod make-object-prototype ((class-name symbol) &optional slot-names)
"Return a PROTOTYPE of an object of the class named by CLASS-NAME."
(let ((package
(max-package slot-names
:initial-value (symbol-package class-name))))
(make-instance 'prototype
:lisp-class class-name
:lisp-package (package-name* package))))
(defmethod make-object-prototype ((object prototype) &optional slot-names)
"Prototypes are not to be given their own prototypes, otherwise we
would proceed ad malinfinitum."
(declare (ignore object slot-names))
nil)
(defun maybe-add-prototype (object prototype)
"If the PROTOTYPE is not NIL, and the OBJECT has a slot to accept it,
do set it. Return OBJECT."
(if (and prototype (slot-exists-p object *prototype-name*))
(setf (slot-value object *prototype-name*) prototype))
object)
(defun map-slots (function object)
"Call FUNCTION on the name and value of every bound slot in OBJECT."
(loop for slot in (class-slots (class-of object))
for slot-name = (slot-definition-name slot)
if (slot-boundp object slot-name)
do (funcall function slot-name (slot-value object slot-name))))
| 15,166 | Common Lisp | .lisp | 316 | 39.905063 | 76 | 0.658657 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | b45fed8f4a046e8ef5a7903473978ba2ff7f9a1215c43a6db812cda50d74b640 | 43,024 | [
408698
] |
43,025 | encoder.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/encoder.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; Copyright (c) 2008 Hans Hübner (marked parts)
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
(defvar *json-output* (make-synonym-stream '*standard-output*)
"The default output stream for encoding operations.")
(define-condition unencodable-value-error (type-error)
((context :accessor unencodable-value-error-context :initarg :context))
(:documentation
"Signalled when a datum is passed to ENCODE-JSON (or another
encoder function) which actually cannot be encoded.")
(:default-initargs :expected-type t)
(:report
(lambda (condition stream)
(with-accessors ((datum type-error-datum)
(context unencodable-value-error-context))
condition
(format stream
"Value ~S is not of a type which can be encoded~@[ by ~A~]."
datum context)))))
(defun unencodable-value-error (value &optional context)
"Signal an UNENCODABLE-VALUE-ERROR."
(error 'unencodable-value-error :datum value :context context))
(defmacro with-substitute-printed-representation-restart ((object stream)
&body body)
"Establish a SUBSTITUTE-PRINTED-REPRESENTATION restart for OBJECT
and execute BODY."
`(restart-case (progn ,@body)
(substitute-printed-representation ()
(let ((repr (with-output-to-string (s)
(write ,object :stream s :escape nil)
nil)))
(write-json-string repr ,stream)))))
(defgeneric encode-json (object &optional stream)
(:documentation "Write a JSON representation of OBJECT to STREAM and
return NIL."))
(defun encode-json-to-string (object)
"Return the JSON representation of OBJECT as a string."
(with-output-to-string (stream)
(encode-json object stream)))
(defmethod encode-json (anything &optional (stream *json-output*))
"If OBJECT is not handled by any specialized encoder signal an error
which the user can correct by choosing to encode the string which is
the printed representation of the OBJECT."
(declare (ignore stream))
(unencodable-value-error anything 'encode-json))
(defmethod encode-json ((nr number) &optional (stream *json-output*))
"Write the JSON representation of the number NR to STREAM (or to
*JSON-OUTPUT*)."
(write-json-number nr stream))
(defmethod encode-json ((s string) &optional (stream *json-output*))
"Write the JSON representation of the string S to STREAM (or to
*JSON-OUTPUT*)."
(write-json-string s stream))
(defmethod encode-json ((c character) &optional (stream *json-output*))
"JSON does not define a character type, we encode characters as Strings."
(encode-json (string c) stream))
(defmethod encode-json ((s symbol) &optional (stream *json-output*))
"Write the JSON representation of the symbol S to STREAM (or to
*JSON-OUTPUT*). If S is boolean, a boolean literal is written.
Otherwise, the name of S is passed to *LISP-IDENTIFIER-NAME-TO-JSON*
and the result is written as String."
(let ((mapped (car (rassoc s +json-lisp-symbol-tokens+))))
(if mapped
(progn (write-string mapped stream) nil)
(let ((s (funcall *lisp-identifier-name-to-json* (symbol-name s))))
(write-json-string s stream)))))
;;; The code below is from Hans Hübner's YASON (with modifications).
(defvar *json-aggregate-context* nil
"NIL outside of any aggregate environment, 'ARRAY or 'OBJECT within
the respective environments.")
(defvar *json-aggregate-first* t
"T when the first member of a JSON Object or Array is encoded,
afterwards NIL.")
(defun next-aggregate-member (context stream)
"Between two members of an Object or Array, print a comma separator."
(if (not (eq context *json-aggregate-context*))
(error "Member encoder used ~:[outside any~;in inappropriate~] ~
aggregate environment"
*json-aggregate-context*))
(prog1 *json-aggregate-first*
(unless *json-aggregate-first*
(write-char #\, stream))
(setq *json-aggregate-first* nil)))
(defmacro with-aggregate ((context begin-char end-char
&optional (stream '*json-output*))
&body body)
"Run BODY to encode a JSON aggregate type, delimited by BEGIN-CHAR
and END-CHAR."
`(let ((*json-aggregate-context* ',context)
(*json-aggregate-first* t))
(declare (special *json-aggregate-context* *json-aggregate-first*))
(write-char ,begin-char ,stream)
(unwind-protect (progn ,@body)
(write-char ,end-char ,stream))))
(defmacro with-array ((&optional (stream '*json-output*)) &body body)
"Open a JSON Array, run BODY, then close the Array. Inside the BODY,
AS-ARRAY-MEMBER or ENCODE-ARRAY-MEMBER should be called to encode
Members of the Array."
`(with-aggregate (array #\[ #\] ,stream) ,@body))
(defmacro as-array-member ((&optional (stream '*json-output*))
&body body)
"BODY should be a program which encodes exactly one JSON datum to
STREAM. AS-ARRAY-MEMBER ensures that the datum is properly formatted
as a Member of an Array, i. e. separated by comma from any preceding
or following Member."
`(progn
(next-aggregate-member 'array ,stream)
,@body))
(defun encode-array-member (object &optional (stream *json-output*))
"Encode OBJECT as the next Member of the innermost JSON Array opened
with WITH-ARRAY in the dynamic context. OBJECT is encoded using the
ENCODE-JSON generic function, so it must be of a type for which an
ENCODE-JSON method is defined."
(next-aggregate-member 'array stream)
(encode-json object stream)
object)
(defun stream-array-member-encoder (stream
&optional (encoder #'encode-json))
"Return a function which takes an argument and encodes it to STREAM
as a Member of an Array. The encoding function is taken from the
value of ENCODER (default is #'ENCODE-JSON)."
(lambda (object)
(as-array-member (stream)
(funcall encoder object stream))))
(defmacro with-object ((&optional (stream '*json-output*)) &body body)
"Open a JSON Object, run BODY, then close the Object. Inside the BODY,
AS-OBJECT-MEMBER or ENCODE-OBJECT-MEMBER should be called to encode
Members of the Object."
`(with-aggregate (object #\{ #\} ,stream) ,@body))
(defmacro as-object-member ((key &optional (stream '*json-output*))
&body body)
"BODY should be a program which writes exactly one JSON datum to
STREAM. AS-OBJECT-MEMBER ensures that the datum is properly formatted
as a Member of an Object, i. e. preceded by the (encoded) KEY and
colon, and separated by comma from any preceding or following Member."
`(progn
(next-aggregate-member 'object ,stream)
(let ((key (encode-json-to-string ,key)))
(if (char= (aref key 0) #\")
(progn (write-string key ,stream) nil)
(encode-json key ,stream)))
(write-char #\: ,stream)
,@body))
(defun encode-object-member (key value
&optional (stream *json-output*))
"Encode KEY and VALUE as a Member pair of the innermost JSON Object
opened with WITH-OBJECT in the dynamic context. KEY and VALUE are
encoded using the ENCODE-JSON generic function, so they both must be
of a type for which an ENCODE-JSON method is defined. If KEY does not
encode to a String, its JSON representation (as a string) is encoded
over again."
(as-object-member (key stream)
(encode-json value stream))
value)
(defun stream-object-member-encoder (stream
&optional (encoder #'encode-json))
"Return a function which takes two arguments and encodes them to
STREAM as a Member of an Object (String : Value pair)."
(lambda (key value)
(as-object-member (key stream)
(funcall encoder value stream))))
;;; End of YASON code.
;;; You can use the streaming encoder above, or
;;; two differnet types of sexp based encoders below
(defun encode-json-list-guessing-encoder (s stream)
"Write the JSON representation of the list S to STREAM (or to
*JSON-OUTPUT*). If S is not encodable as a JSON Array, try to encode
it as an Object (per ENCODE-JSON-ALIST)."
(restart-case
(handler-bind ((unencodable-value-error
(lambda (e)
(with-accessors ((datum type-error-datum)) e
(if (and (consp datum)
(ignore-errors (every #'consp s)))
(invoke-restart 'try-as-alist)
(error e)))))
(type-error
(lambda (e)
(declare (ignore e))
(unencodable-value-error s 'encode-json))))
(write-string
(with-output-to-string (temp)
(with-array (temp)
(mapcar (stream-array-member-encoder temp) s)))
stream))
(try-as-alist ()
(encode-json-alist s stream)))
(values))
(defun json-bool (value)
"Intended for the JSON-EXPLICT-ENCODER. Converts a non-nil value
to a value (:true) that creates a json true value when used in the
explict encoder. Or (:false)."
(if value
'(:true)
'(:false)))
(defun json-or-null (value)
"Intended for the JSON-EXPLICT-ENCODER. Returns a non-nil value
as itself, or a nil value as a json null-value"
(or value '(:null)))
(defun encode-json-list-explicit-encoder (s stream)
(handler-bind ((type-error
(lambda (e)
(declare (ignore e))
(unencodable-value-error s 'encode-json))))
(ecase (car s)
(:json (mapcar (lambda (str) (write-string str stream))
(cdr s)))
(:true (write-json-chars "true" stream))
(:false (write-json-chars "false" stream))
(:null (write-json-chars "null" stream))
((:list :array)
(with-array (stream)
(mapcar (stream-array-member-encoder stream)
(cdr s))))
(:object (if (consp (cadr s))
(encode-json-alist (cdr s) stream)
(encode-json-plist (cdr s) stream)))
(:alist (encode-json-alist (cdr s) stream))
(:plist (encode-json-plist (cdr s) stream)))
nil))
(defparameter *json-list-encoder-fn* 'encode-json-list-guessing-encoder)
(defun use-guessing-encoder ()
(setf *json-list-encoder-fn* 'encode-json-list-guessing-encoder))
(defun use-explicit-encoder ()
(setf *json-list-encoder-fn* 'encode-json-list-explicit-encoder))
(defmacro with-local-encoder (&body body)
`(let (*json-list-encoder-fn*)
(declare (special *json-list-encoder-fn*))
,@body))
(defmacro with-guessing-encoder (&body body)
`(with-local-encoder (use-guessing-encoder)
,@body))
(defmacro with-explicit-encoder (&body body)
`(with-local-encoder (use-explicit-encoder)
,@body))
(defmethod encode-json ((s list) &optional (stream *json-output*))
"Write the JSON representation of the list S to STREAM (or to
*JSON-OUTPUT*), using one of the two rules specified by
first calling USE-GUESSING-ENCODER or USE-EXPLICIT-ENCODER.
The guessing encoder: If S is a list encode S as a JSON Array, if
S is a dotted list encode it as an Object (per ENCODE-JSON-ALIST).
The explicit decoder: If S is a list, the first symbol defines
the encoding:
If (car S) is 'TRUE return a JSON true value.
If (car S) is 'FALSE return a JSON false value.
If (car S) is 'NULL return a JSON null value.
If (car S) is 'JSON princ the strings in (cdr s) to stream
If (car S) is 'LIST or 'ARRAY encode (cdr S) as a a JSON Array.
If (car S) is 'OBJECT encode (cdr S) as A JSON Object,
interpreting (cdr S) either as an A-LIST or a P-LIST."
(funcall *json-list-encoder-fn* s stream))
(defmethod encode-json ((s sequence) &optional (stream *json-output*))
"Write the JSON representation (Array) of the sequence S (not an
alist) to STREAM (or to *JSON-OUTPUT*)."
(with-array (stream)
(map nil (stream-array-member-encoder stream) s)))
(defmethod encode-json ((h hash-table) &optional (stream *json-output*))
"Write the JSON representation (Object) of the hash table H to
STREAM (or to *JSON-OUTPUT*)."
(with-object (stream)
(maphash (stream-object-member-encoder stream) h)))
#+cl-json-clos
(defmethod encode-json ((o standard-object)
&optional (stream *json-output*))
"Write the JSON representation (Object) of the CLOS object O to
STREAM (or to *JSON-OUTPUT*)."
(with-object (stream)
(map-slots (stream-object-member-encoder stream) o)))
(defun encode-json-alist (alist &optional (stream *json-output*))
"Write the JSON representation (Object) of ALIST to STREAM (or to
*JSON-OUTPUT*). Return NIL."
(write-string
(with-output-to-string (temp)
(with-object (temp)
(loop
with bindings = alist
do (if (listp bindings)
(if (endp bindings)
(return)
(let ((binding (pop bindings)))
(if (consp binding)
(destructuring-bind (key . value) binding
(encode-object-member key value temp))
(unless (null binding)
(unencodable-value-error
alist 'encode-json-alist)))))
(unencodable-value-error alist 'encode-json-alist)))))
stream)
nil)
(defun encode-json-alist-to-string (alist)
"Return the JSON representation (Object) of ALIST as a string."
(with-output-to-string (stream)
(encode-json-alist alist stream)))
(defun encode-json-plist (plist &optional (stream *json-output*))
"Write the JSON representation (Object) of PLIST to STREAM (or to
*JSON-OUTPUT*). Return NIL."
(write-string
(with-output-to-string (temp)
(with-object (temp)
(loop
with properties = plist
do (if (listp properties)
(if (endp properties)
(return)
(let ((indicator (pop properties)))
(if (and (listp properties)
(not (endp properties)))
(encode-object-member
indicator (pop properties) temp)
(unencodable-value-error
plist 'encode-json-plist))))
(unencodable-value-error plist 'encode-json-plist)))))
stream)
nil)
(defun encode-json-plist-to-string (plist)
"Return the JSON representation (Object) of PLIST as a string."
(with-output-to-string (stream)
(encode-json-plist plist stream)))
(defun write-json-string (s stream)
"Write a JSON representation (String) of S to STREAM."
(write-char #\" stream)
(if (stringp s)
(write-json-chars s stream)
(encode-json s stream))
(write-char #\" stream)
nil)
(defun write-json-chars (s stream)
"Write JSON representations (chars or escape sequences) of
characters in string S to STREAM."
(loop for ch across s
for code = (char-code ch)
with special
if (setq special (car (rassoc ch +json-lisp-escaped-chars+)))
do (write-char #\\ stream) (write-char special stream)
else if (< #x1f code #x7f)
do (write-char ch stream)
else
do (let ((special '#.(rassoc-if #'consp +json-lisp-escaped-chars+)))
(destructuring-bind (esc . (width . radix)) special
(format stream "\\~C~V,V,'0R" esc radix width code)))))
(eval-when (:compile-toplevel :execute)
(if (subtypep 'long-float 'single-float)
;; only one float type
(pushnew :cl-json-only-one-float-type *features*)
;; else -- we check here only for the case where there are two
;; float types, single- and double- --- we don't consider the
;; "only single and short" case. Could be added if necessary.
(progn
(when (subtypep 'single-float 'short-float)
(pushnew :cl-json-single-float-is-subsumed *features*))
(when (subtypep 'long-float 'double-float)
(pushnew :cl-json-double-float-is-subsumed *features*)))))
(defun write-json-number (nr stream)
"Write the JSON representation of the number NR to STREAM."
(typecase nr
(integer (format stream "~d" nr))
(real (let ((*read-default-float-format*
(etypecase nr
(short-float 'short-float)
(rational 'single-float)
#-(or cl-json-single-float-is-subsumed
cl-json-only-one-float-type)
(single-float 'single-float)
#-(or cl-json-double-float-is-subsumed
cl-json-only-one-float-type)
(double-float 'double-float)
#-cl-json-only-one-float-type
(long-float 'long-float))))
(format stream "~f" nr)))
(t (unencodable-value-error nr 'write-json-number))))
| 17,153 | Common Lisp | .lisp | 373 | 38.453083 | 75 | 0.648153 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 8a090b7d7d434779d395e63ecbd6a4c2a05772c9e41463955b2e0964697543aa | 43,025 | [
17953
] |
43,026 | utils.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/utils.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
(defun range-keys (var-keys)
(loop for var-key in var-keys
for (primary-key . subkey) =
(destructuring-bind (var . key) var-key
(let ((dot (position #\. key :test #'char=)))
(if dot
(cons (subseq key 0 dot) (cons var (subseq key (1+ dot))))
(cons key var))))
for subkeys-of-primary =
(assoc primary-key subkeys :test #'string=)
if subkeys-of-primary
do (push subkey (cdr subkeys-of-primary))
else
collect (cons primary-key (list subkey)) into subkeys
finally (return subkeys)))
(defun json-bind-level-customizations (level-keys value-required
decoder validator
key-handler value-handler pass)
(loop for (key . subs) in (range-keys level-keys)
with subkeys and vars-to-bind
do (loop for sub in subs
initially (setq subkeys nil vars-to-bind nil)
if (consp sub) do (push sub subkeys)
else do (push sub vars-to-bind))
collect
`((string= key ,key)
(set-custom-vars
:internal-decoder
,(if (endp subkeys)
(if vars-to-bind decoder validator)
(cons 'custom-decoder
(json-bind-level-customizations
subkeys vars-to-bind decoder validator
key-handler value-handler pass)))
:object-value
(lambda (value)
(declare (ignorable value))
,@(loop for var in vars-to-bind collect `(setq ,var value))
,(if value-required `(funcall ,value-handler value)))))
into match-clauses
finally
(return
`(:object-key
(lambda (key)
(let ((key (funcall *json-identifier-name-to-lisp* key)))
(cond
,@match-clauses
(t ,(if value-required
(list 'set-custom-vars
:internal-decoder decoder
:object-value value-handler)
(list 'set-custom-vars
:internal-decoder validator
:object-value pass)))))
,(if value-required
`(funcall ,key-handler key)))))))
(defmacro json-bind ((&rest vars) json-source &body body)
(let-gensyms (decoder validator value-handler key-handler pass)
(let ((vars-tmp (loop repeat (length vars) collect (gensym))))
`(let (,@vars-tmp (,pass (constantly t)))
(let ((,validator
(custom-decoder
:beginning-of-object ,pass :object-key ,pass
:object-value ,pass :end-of-object ,pass
:beginning-of-array ,pass :array-member ,pass
:end-of-array ,pass :beginning-of-string ,pass
:string-char ,pass :end-of-string ,pass
:internal-decoder 'decode-json))
(,decoder (current-decoder))
(,key-handler *object-key-handler*)
(,value-handler *object-value-handler*))
(declare (ignorable ,decoder ,key-handler ,value-handler))
,(if (null vars)
`(decode-json-from-source ,json-source ,validator)
`(bind-custom-vars
(,@(json-bind-level-customizations
(loop for var in vars for var-tmp in vars-tmp
collect (cons var-tmp (symbol-name var)))
nil decoder validator
key-handler value-handler pass)
:aggregate-scope
(union *aggregate-scope-variables*
'(*object-key-handler*
*object-value-handler*
*internal-decoder*)))
(decode-json-from-source ,json-source))))
(let ,(mapcar #'list vars vars-tmp)
,@body)))))
;;; Old code:
;;; helpers for json-bind
;(defun cdas(item alist)
; "Alias for (cdr (assoc item alist))"
; (cdr (assoc item alist)))
;
;(defun last1 (lst)
; (first (last lst)))
;
;(defmacro assoc-lookup (&rest lookuplist)
; "(assoc-lookup :x :y alist) => (cdr (assoc :y (cdr (assoc :x alist))))"
; (let ((alist-form (last1 lookuplist))
; (lookups (reverse (butlast lookuplist))))
; (labels ((mk-assoc-lookup (lookuplist)
; (if lookuplist
; `(cdas ,(first lookuplist) ,(mk-assoc-lookup (rest lookuplist)))
; alist-form)))
; (mk-assoc-lookup lookups))))
;
;(defmacro json-bind (vars json-string-or-alist &body body)
; (labels ((symbol-as-string (symbol)
; (string-downcase (symbol-name symbol)))
; (split-by-dots (string)
; (loop for ch across string
; with x
; with b
; do (if (char= #\. ch)
; (progn
; (push (concatenate 'string (nreverse b)) x)
; (setf b nil))
; (push ch b))
; finally (progn
; (push (concatenate 'string (nreverse b)) x)
; (return (nreverse x)))))
; (lookup-deep (variable)
; (mapcar (lambda (nm) `(json-intern ,nm))
; (split-by-dots (symbol-as-string variable)))))
; (let ((a-list (gensym)))
; `(let ((,a-list (if (stringp ,json-string-or-alist)
; (decode-json-from-string ,json-string-or-alist)
; ,json-string-or-alist)))
; (let ,(loop for v in vars collect `(,v (assoc-lookup ,@(lookup-deep v)
; ,a-list)))
; ,@body)))))
| 6,053 | Common Lisp | .lisp | 137 | 33.992701 | 83 | 0.513198 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 7df4efaae27908636d9d5ad327bb2f490bc62c63ff8821a0b6f3af72117cdb1a | 43,026 | [
187543
] |
43,027 | decoder-args.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/decoder-args.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
(in-package :json)
;;; Custom variables
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar *custom-vars* nil)
(defmacro with-shadowed-custom-vars (&body body)
`(let ,(loop for (var) in *custom-vars*
collect `(,var (if (boundp ',var) ,var)))
,@body))
(defmacro set-custom-vars (&rest key-args)
`(setq
,@(loop for (supplied-key value) on key-args by #'cddr
append (loop for (var . var-key) in *custom-vars*
thereis (if (eql var-key supplied-key)
(list var value))))))
)
(defmacro define-custom-var ((key name) &rest other-args)
`(eval-when (:compile-toplevel :load-toplevel :execute)
(progn (pushnew '(,name . ,key) *custom-vars* :test #'equal)
(defvar ,name ,@other-args))))
;;; Token reader
(define-condition json-syntax-error (simple-error stream-error)
((stream-file-position :reader stream-error-stream-file-position
:initarg :stream-file-position))
(:report
(lambda (condition stream)
(format stream "~? [in ~S~@[ at position ~D~]]"
(simple-condition-format-control condition)
(simple-condition-format-arguments condition)
(stream-error-stream condition)
(stream-error-stream-file-position condition)))))
(defun json-syntax-error (stream format-control &rest format-arguments)
(error 'json-syntax-error
:stream stream
:stream-file-position (file-position stream)
:format-control format-control
:format-arguments format-arguments))
(defun read-json-token (stream)
(let ((c (peek-char t stream)))
(case c
((#\{ #\[ #\] #\} #\" #\: #\,)
(values :punct (read-char stream)))
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 #\-)
(read-json-number-token stream))
(t (if (alpha-char-p c)
(read-json-symbol-token stream)
(json-syntax-error stream "Invalid char on JSON input: `~C'"
c))))))
(defun read-json-number-token (stream)
(let ((int (make-array 32 :adjustable t :fill-pointer 0
:element-type 'character))
(frac (make-array 32 :adjustable t :fill-pointer 0
:element-type 'character))
(exp (make-array 32 :adjustable t :fill-pointer 0
:element-type 'character))
(type :integer)
c)
(flet ((safe-read-char (stream)
(handler-case (read-char stream)
(end-of-file ()
(return-from read-json-number-token
(values type (concatenate 'string int frac exp)))))))
(macrolet
((read-digits (part)
(let ((error-fmt
(format nil "Invalid JSON number: no ~(~A~) digits"
part)))
`(loop while (char<= #\0 c #\9)
with count = 0
do (vector-push-extend c ,part 32)
(setq c (safe-read-char stream))
(incf count)
finally
(if (zerop count)
(json-syntax-error stream ,error-fmt))))))
(setq c (read-char stream))
(when (char= c #\-)
(vector-push c int)
(setq c (read-char stream)))
(if (char= c #\0)
(progn
(vector-push c int)
(setq c (safe-read-char stream)))
(read-digits int))
(when (char= c #\.)
(vector-push c frac)
(setq c (read-char stream)
type :real)
(read-digits frac))
(when (char-equal c #\e)
(vector-push c exp)
(setq c (read-char stream)
type :real)
(when (or (char= c #\+) (char= c #\-))
(vector-push c exp)
(setq c (read-char stream)))
(read-digits exp))
(unread-char c stream)
(values type (concatenate 'string int frac exp))))))
(defun read-json-symbol-token (stream)
(let ((symbol (make-array 8 :adjustable t :fill-pointer 0
:element-type 'character)))
(loop for c = (read-char stream nil)
while (and c (alpha-char-p c))
do (vector-push-extend c symbol 32)
finally (if c (unread-char c stream)))
(setq symbol (coerce symbol 'string))
(if (or (string= symbol "true")
(string= symbol "false")
(string= symbol "null"))
(values :boolean symbol)
(json-syntax-error stream "Invalid JSON symbol: ~A" symbol))))
(define-condition no-char-for-code (error)
((offending-code :initarg :code :reader offending-code))
(:report (lambda (condition stream)
(format stream "No character corresponds to code #x~4,'0X."
(offending-code condition)))))
(defun read-json-string-char (stream)
(let ((esc-error-fmt "Invalid JSON character escape sequence: ~A~A"))
(case (peek-char nil stream)
(#\" (read-char stream)
nil) ; End of string
(#\\ (read-char stream)
(let ((c (read-char stream)))
(case c
((#\" #\\ #\/) c)
(#\r #\Return)
(#\n #\Linefeed)
(#\t #\Tab)
(#\b #\Backspace)
(#\f #\ )
(#\u (let ((hex (make-string 4)))
(dotimes (i 4)
(setf (aref hex i) (read-char stream)))
(let ((c (handler-case (parse-integer hex :radix 16)
(parse-error ()
(json-syntax-error stream esc-error-fmt
"\\u" hex)))))
(if (< c 256)
(code-char c)
(restart-case (error 'no-char-for-code :code c)
(substitute-char (char)
:report "Substitute another char."
:interactive
(lambda ()
(format *query-io* "Char: ")
(list (read-char *query-io*)))
char)
(pass-code ()
:report "Pass the code to char handler."
c))))))
(t (json-syntax-error stream esc-error-fmt "\\" c)))))
(t (read-char stream)))))
;;; The decoder base
(define-custom-var (:integer *integer-handler*))
(define-custom-var (:real *real-handler*))
(define-custom-var (:boolean *boolean-handler*))
(define-custom-var (:beginning-of-string *beginning-of-string-handler*))
(define-custom-var (:string-char *string-char-handler*))
(define-custom-var (:end-of-string *end-of-string-handler*))
(define-custom-var (:beginning-of-array *beginning-of-array-handler*))
(define-custom-var (:array-element *array-element-handler*))
(define-custom-var (:end-of-array *end-of-array-handler*))
(define-custom-var (:beginning-of-object *beginning-of-object-handler*))
(define-custom-var (:object-key *object-key-handler*))
(define-custom-var (:object-value *object-value-handler*))
(define-custom-var (:end-of-object *end-of-object-handler*))
(defun decode-json (stream &optional parent-handler-state)
(multiple-value-bind (type token) (read-json-token stream)
(dispatch-on-token type token parent-handler-state stream)))
(defun dispatch-on-token (type token parent-handler-state stream)
(ecase type
(:punct
(case token
(#\" (decode-json-string stream parent-handler-state))
(#\[ (decode-json-array stream parent-handler-state))
(#\{ (decode-json-object stream parent-handler-state))
(t (json-syntax-error stream
"Token out of place on JSON input: `~C'"
token))))
(:integer
(funcall *integer-handler* parent-handler-state token))
(:real
(funcall *real-handler* parent-handler-state token))
(:boolean
(funcall *boolean-handler* parent-handler-state token))))
(defun decode-json-array (stream &optional parent-handler-state)
(let ((handler-state
(funcall *beginning-of-array-handler* parent-handler-state)))
(multiple-value-bind (type token) (read-json-token stream)
(if (and (eql type :punct) (char= token #\]))
(return-from decode-json-array
(funcall *end-of-array-handler* handler-state))
(setq handler-state
(funcall *array-element-handler* handler-state
(dispatch-on-token type token handler-state
stream)))))
(loop
(multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\] (return-from decode-json-array
(funcall *end-of-array-handler* handler-state)))
(#\, (setq token nil))))
(if token
(json-syntax-error
stream
"Token out of place in array on JSON input: `~A'"
token)))
(setq handler-state
(funcall *array-element-handler* handler-state
(decode-json stream handler-state))))))
(defun decode-json-object (stream &optional parent-handler-state)
(loop with handler-state =
(funcall *beginning-of-object-handler* parent-handler-state)
with key = nil
for first-time-p = t then nil
do (multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\}
(if first-time-p
(return-from decode-json-object
(funcall *end-of-object-handler* handler-state))))
(#\"
(setq key (decode-json-string stream handler-state t)))))
(if key
(setq handler-state
(funcall *object-key-handler* handler-state key))
(json-syntax-error
stream
"Expected a key string in object on JSON input ~
but found `~A'"
token)))
(multiple-value-bind (type token) (read-json-token stream)
(unless (and (eql type :punct) (char= token #\:))
(json-syntax-error
stream
"Expected a `:' separator in object on JSON input ~
but found `~A'"
token)))
(setq handler-state
(funcall *object-value-handler* handler-state
(decode-json stream handler-state)))
(multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\} (return-from decode-json-object
(funcall *end-of-object-handler* handler-state)))
(#\, (setq key nil))))
(if key
(json-syntax-error
stream
"Expected a `,' separator or `}' in object on JSON input ~
but found `~A'"
token)))))
(defun decode-json-string (stream &optional parent-handler-state
as-object-key)
(loop with handler-state = (funcall *beginning-of-string-handler*
parent-handler-state as-object-key)
for c = (read-json-string-char stream)
while c
do (setq handler-state
(funcall *string-char-handler* handler-state c))
finally (return
(funcall *end-of-string-handler* handler-state))))
;;; Name translation
(defun camel-case-split (string)
(let ((length (length string)))
(macrolet ((shift-part (e new-cat &optional subst-cat)
`(prog1 (if b (cons ,(or subst-cat 'cat)
(subseq string b ,e)))
(setq b ,e cat ,new-cat))))
(loop for i from 0 to length
with cat = nil and b = nil
if (= i length)
if (shift-part i nil) collect it end
else if (let ((c (aref string i)))
(cond
((upper-case-p c)
(case cat
((:upper-1 :upper) (setq cat :upper) nil)
(t (shift-part i :upper-1))))
((lower-case-p c)
(case cat
(:upper-1 (setq cat :mixed) nil)
(:upper (let ((subst-cat
(if (> (- i b) 2) :upper :upper-1)))
(shift-part (1- i) :mixed subst-cat)))
((:numeric :punct nil) (shift-part i :lower))))
((digit-char-p c)
(if (not (eql cat :numeric))
(shift-part i :numeric)))
(t (shift-part i :punct))))
collect it))))
(defun camel-case-transform-all-caps (parts
&optional cat-before from-numeric)
(if (endp parts)
(cond (from-numeric (throw 'all-caps nil))
((eql cat-before :punct) nil)
(t '("+")))
(destructuring-bind ((cat . part) . rest) parts
(case cat
((:lower :mixed) (throw 'all-caps nil))
(:punct
(let ((transformed (if (string= part "_") "-" part)))
(if (or from-numeric (eql cat-before :punct))
(cons transformed (camel-case-transform-all-caps rest cat))
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(cons transformed transformed-rest)
(list* "+"
(if (string= part "_") "--" part)
(camel-case-transform rest cat)))))))
((:upper :upper1)
(cons part (camel-case-transform-all-caps rest cat nil)))
(t (cons part (camel-case-transform-all-caps
rest cat from-numeric)))))))
(defun camel-case-transform (parts &optional (cat-before :punct))
(if (endp parts)
'("")
(destructuring-bind ((cat . part) . rest) parts
(case cat
(:upper
(if (eql cat-before :punct)
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(list* "+" part transformed-rest)
(list* "+" part "+" (camel-case-transform rest cat))))
(list* "-+" part "+" (camel-case-transform rest cat))))
(:upper-1
(case cat-before
(:punct
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(list* "+" part transformed-rest)
(list* "*" part (camel-case-transform rest cat)))))
(:numeric (list* "-*" part (camel-case-transform rest cat)))
(t (list* "-" part (camel-case-transform rest cat)))))
(:numeric
(case cat-before
(:punct
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat t))))
(if transformed-rest
(list* "+" part transformed-rest)
(cons part (camel-case-transform rest cat)))))
(t (list* "-" part (camel-case-transform rest cat)))))
(:mixed
(list* (case cat-before (:punct "*") (:numeric "-*") (t "-"))
(string-upcase part)
(camel-case-transform rest cat)))
(:lower
(list* (if (eql cat-before :punct) "" "-")
(string-upcase part)
(camel-case-transform rest cat)))
(:punct
(cons (if (string= part "_") "--" part)
(camel-case-transform rest cat)))))))
(defun camel-case-to-lisp (string)
(apply #'concatenate 'string
(camel-case-transform (camel-case-split string))))
(define-custom-var (:symbols-package *json-symbols-package*)
(find-package 'keyword))
(defun json-intern (string)
(intern string *json-symbols-package*))
;;; The list semantics
(define-custom-var (:array-type *json-array-type*) 'vector)
(defun parse-number (parent-handler-state token)
(declare (ignore parent-handler-state))
;; We can be reasonably sure that nothing but well-formed (both in
;; JSON and Lisp sense) number literals gets to this point.
(read-from-string token))
(defun json-boolean-to-lisp (parent-handler-state token)
(declare (ignore parent-handler-state))
(string= token "true"))
(defun make-accumulator (parent-handler-state)
(declare (ignore parent-handler-state))
(let ((head (cons nil nil)))
(cons head head)))
(defun accumulator-add (accumulator element)
(destructuring-bind (head . last) accumulator
(cons head (setf (cdr last) (cons element nil)))))
(defun accumulator-add-key (accumulator key)
(destructuring-bind (head . last) accumulator
(cons head
(let ((key (json-intern (camel-case-to-lisp key))))
(setf (cdr last) (cons (cons key nil) nil))))))
(defun accumulator-add-value (accumulator value)
(destructuring-bind (head . last) accumulator
(declare (ignore head))
(setf (cdar last) value)
accumulator))
(defun accumulator-get-sequence (accumulator)
(coerce (cdar accumulator) *json-array-type*))
(defun accumulator-get (accumulator)
(cdar accumulator))
(defun make-vector-accumulator (parent-accumulator &optional as-object-key)
(declare (ignore parent-accumulator as-object-key))
(make-array 32 :adjustable t :fill-pointer 0))
(defun vector-accumulator-add (accumulator element)
(vector-push-extend element accumulator (fill-pointer accumulator))
accumulator)
(defun vector-accumulator-get-sequence (accumulator)
(coerce accumulator *json-array-type*))
(defun vector-accumulator-get-string (accumulator)
(coerce accumulator 'string))
(defun set-decoder-simple-list-semantics ()
(set-custom-vars
:integer #'parse-number
:real #'parse-number
:boolean #'json-boolean-to-lisp
:beginning-of-array #'make-accumulator
:array-element #'accumulator-add
:end-of-array #'accumulator-get-sequence
:beginning-of-object #'make-accumulator
:object-key #'accumulator-add-key
:object-value #'accumulator-add-value
:end-of-object #'accumulator-get
:beginning-of-string #'make-vector-accumulator
:string-char #'vector-accumulator-add
:end-of-string #'vector-accumulator-get-string))
(defmacro with-decoder-simple-list-semantics (&body body)
`(with-shadowed-custom-vars
(set-decoder-simple-list-semantics)
,@body))
;;; The CLOS semantics
(defvar *prototype-prototype*
(make-instance 'prototype
:lisp-class 'prototype
:lisp-package :json))
(defun make-accumulator-with-prototype (parent-handler-state)
(if (and (consp parent-handler-state)
(consp (car parent-handler-state))
(eql (caar parent-handler-state) t))
(let ((head (cons *prototype-prototype* nil)))
(cons head head))
(make-accumulator parent-handler-state)))
(defun accumulator-add-key-or-set-prototype (accumulator key)
(destructuring-bind (head . last) accumulator
(let ((key (camel-case-to-lisp key)))
(if (and (not (car head))
*prototype-name*
(string= key (symbol-name *prototype-name*)))
(progn (setf (car head) t)
accumulator)
(cons head
(setf (cdr last) (cons (cons key nil) nil)))))))
(defun accumulator-add-value-or-set-prototype (accumulator value)
(destructuring-bind (head . last) accumulator
(declare (ignore last))
(if (and (consp head) (eql (car head) t))
(progn
(assert (typep value 'prototype) (value)
"Invalid prototype: ~S. Want to substitute something else?"
value)
(setf (car head) value)
accumulator)
(accumulator-add-value accumulator value))))
(defun accumulator-get-object (accumulator)
(destructuring-bind (head . last) accumulator
(declare (ignore last))
(flet ((as-symbol (value)
(if (stringp value)
(json-intern (camel-case-to-lisp value))
value))
(intern-keys (bindings)
(loop for (key . value) in bindings
collect (cons (json-intern key) value))))
(if (typep (car head) 'prototype)
(with-slots (lisp-class lisp-superclasses lisp-package)
(car head)
(let* ((*json-symbols-package*
(or (find-package (as-symbol lisp-package))
*json-symbols-package*))
(class (as-symbol lisp-class))
(superclasses (mapcar #'as-symbol lisp-superclasses)))
(make-object (intern-keys (cdr head)) class
:superclasses superclasses)))
(make-object (intern-keys (cdr head)) nil)))))
(defun set-decoder-simple-clos-semantics ()
(set-custom-vars
:integer #'parse-number
:real #'parse-number
:boolean #'json-boolean-to-lisp
:beginning-of-array #'make-vector-accumulator
:array-element #'vector-accumulator-add
:end-of-array #'vector-accumulator-get-sequence
:beginning-of-object #'make-accumulator-with-prototype
:object-key #'accumulator-add-key-or-set-prototype
:object-value #'accumulator-add-value-or-set-prototype
:end-of-object #'accumulator-get-object
:beginning-of-string #'make-vector-accumulator
:string-char #'vector-accumulator-add
:end-of-string #'vector-accumulator-get-string))
(defmacro with-decoder-simple-clos-semantics (&body body)
`(with-shadowed-custom-vars
(set-decoder-simple-clos-semantics)
,@body))
| 22,404 | Common Lisp | .lisp | 506 | 32.563241 | 76 | 0.553652 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | aca141ba8a74e2a83ea89266b91fc3348abd770a2d51470fcfc53fca031e1b6f | 43,027 | [
247195
] |
43,028 | common.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/common.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
(defmacro let-gensyms ((&rest names) &body body)
`(let ,(loop for name in names collect `(,name (gensym)))
,@body))
;;; Custom variables
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar *custom-vars* nil)
(defmacro with-shadowed-custom-vars (&body body)
`(let ,(loop for (var) in *custom-vars*
collect `(,var (if (boundp ',var) ,var)))
,@body))
(defun custom-key-to-variable (key)
(car (rassoc key *custom-vars*)))
(defmacro loop-on-custom ((key var &optional value) &rest clauses)
(if value
(destructuring-bind (key-args . clauses) clauses
`(loop for (,key ,value) on ,key-args by #'cddr
for ,var = (custom-key-to-variable ,key)
if ,var ,@clauses))
`(loop for (,var . ,key) in *custom-vars*
,@clauses)))
(defmacro set-custom-vars (&rest customizations)
`(setq
,@(loop-on-custom (key var value) customizations
append (list var value))))
(defmacro bind-custom-vars ((&rest customizations) &body body)
`(let ,(loop-on-custom (key var value) customizations
collect (list var value))
,@body))
)
(defmacro define-custom-var ((key name) &rest other-args)
`(eval-when (:compile-toplevel :load-toplevel :execute)
(progn (pushnew '(,name . ,key) *custom-vars* :test #'equal)
(defvar ,name ,@other-args))))
;;; Characters
(defparameter +json-lisp-escaped-chars+
'((#\" . #\")
(#\\ . #\\)
(#\/ . #\/)
(#\b . #\Backspace)
(#\f . #\ )
(#\n . #\Newline)
(#\r . #\Return)
(#\t . #\Tab)
(#\u . (4 . 16)))
"Mapping between JSON String escape sequences and Lisp chars.")
(defvar *use-strict-json-rules* t
"If non-nil, signal error on unrecognized escape sequences in JSON
Strings. If nil, translate any such sequence to the char after
slash.")
;;; Symbols
(defparameter +json-lisp-symbol-tokens+
'(("true" . t)
("null" . nil)
("false" . nil))
"Mapping between JSON literal names and Lisp boolean values.")
(defvar *json-symbols-package* (find-package 'keyword)
"The package where JSON Object keys etc. are interned.
Default KEYWORD, NIL = use current *PACKAGE*.")
(defun json-intern (string)
"Intern STRING in the current *JSON-SYMBOLS-PACKAGE*."
(intern string (or *json-symbols-package* *package*)))
(define-condition unknown-symbol-error (parse-error)
((datum :accessor unknown-symbol-error-datum :initarg :datum))
(:documentation
"Signalled by safe-json-intern when a symbol that is
not already interned in *json-symbols-package* is found.")
(:report
(lambda (condition stream)
(format stream
"SAFE-JSON-INTERN only allows previously interned symbols, ~A is not interned in *json-symbols-package*"
(unknown-symbol-error-datum condition)))))
(defun unknown-symbol-error (string)
(error 'unknown-symbol-error :datum string))
(defun safe-json-intern (string)
"The default json-intern is not safe. Interns of many
unique symbols could potentially use a lot of memory.
An attack could exploit this by submitting something that is passed
through cl-json that has many very large, unique symbols. This version
is safe in that respect because it only allows symbols that already
exists."
(or (find-symbol string
(or *json-symbols-package* *package*))
(unknown-symbol-error string)))
(defvar *json-identifier-name-to-lisp* 'camel-case-to-lisp
"Designator for a function which maps string (a JSON Object key) to
string (name of a Lisp symbol).")
(defvar *lisp-identifier-name-to-json* 'lisp-to-camel-case
"Designator for a function which maps string (name of a Lisp symbol)
to string (e. g. JSON Object key).")
(defvar *identifier-name-to-key* 'json-intern
"Designator for a function which, during decoding, maps the *json-identifier-name-to-lisp*
-transformed key to the value it will have in the result object.")
| 4,135 | Common Lisp | .lisp | 97 | 38.484536 | 117 | 0.684867 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 65ccf90b63187e41111d4b980bf1ff053af1d2ef6d0ecd447f3507acb18a19fb | 43,028 | [
352832
] |
43,029 | camel-case.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/camel-case.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
;;; First a simpler version, see testcase json-object-simplified-camel-case
;;; for difference with the ordinary came-case-to-lisp
(defun simplified-camel-case-to-lisp (camel-string)
"Insert - between lowercase and uppercase chars.
Ignore _ + * and several consecutive uppercase."
(declare (string camel-string))
(let ((*print-pretty* nil))
(with-output-to-string (result)
(loop for c across camel-string
with last-was-lowercase
when (and last-was-lowercase
(upper-case-p c))
do (princ "-" result)
if (lower-case-p c)
do (setf last-was-lowercase t)
else
do (setf last-was-lowercase nil)
do (princ (char-upcase c) result)))))
(defun camel-case-split (string)
"Assume STRING is in camel case, and split it into largest possible
``homogenous'' parts. A homogenous part consists either a) of
upper-case alphabetic chars; or b) of lower-case alphabetic chars with
an optional initial upper-case; or c) of decimal digits; or d) of a
single non-alphanumeric char. The return value is a list of
pairs (CATEGORY . PART) where CATEGORY is one of the keywords :UPPER,
:UPPER-1, :LOWER, :NUMERIC, :MIXED, and PART is a substring of
STRING."
(let ((length (length string)))
(macrolet ((shift-part (e new-cat &optional subst-cat)
`(prog1 (if b (cons ,(or subst-cat 'cat)
(subseq string b ,e)))
(setq b ,e cat ,new-cat))))
(loop for i from 0 to length
with cat = nil and b = nil
if (= i length)
if (shift-part i nil) collect it end
else if (let ((c (aref string i)))
(cond
((upper-case-p c)
(case cat
((:upper-1 :upper) (setq cat :upper) nil)
(t (shift-part i :upper-1))))
((lower-case-p c)
(case cat
(:upper-1 (setq cat :mixed) nil)
(:upper (let ((subst-cat
(if (> (- i b) 2) :upper :upper-1)))
(shift-part (1- i) :mixed subst-cat)))
((:numeric :punct nil) (shift-part i :lower))))
((digit-char-p c)
(if (not (eql cat :numeric))
(shift-part i :numeric)))
(t (shift-part i :punct))))
collect it))))
(defun camel-case-transform-all-caps (parts
&optional cat-before from-numeric)
"Take a list of PARTS (as returned by CAMEL-CASE-SPLIT) and
transform it into a string with Lisp-style hyphenation, assuming that
some initial portion of it does not contain :MIXED parts."
(if (endp parts)
(cond (from-numeric (throw 'all-caps nil))
((eql cat-before :punct) nil)
(t '("+")))
(destructuring-bind ((cat . part) . rest) parts
(case cat
((:lower :mixed) (throw 'all-caps nil))
(:punct
(let ((transformed (if (string= part "_") "-" part)))
(if (or from-numeric (eql cat-before :punct))
(cons transformed (camel-case-transform-all-caps rest cat))
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(cons transformed transformed-rest)
(list* "+"
(if (string= part "_") "--" part)
(camel-case-transform rest cat)))))))
((:upper :upper1)
(cons part (camel-case-transform-all-caps rest cat nil)))
(t (cons part (camel-case-transform-all-caps
rest cat from-numeric)))))))
(defun camel-case-transform (parts &optional (cat-before :punct))
"Take a list of PARTS (as returned by CAMEL-CASE-SPLIT) and
transform it into a string with Lisp-style hyphenation, assuming that
some initial portion of it does not contain :UPPER parts."
(if (endp parts)
'("")
(destructuring-bind ((cat . part) . rest) parts
(case cat
(:upper
(if (eql cat-before :punct)
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(list* "+" part transformed-rest)
(list* "+" part "+" (camel-case-transform rest cat))))
(list* "-+" part "+" (camel-case-transform rest cat))))
(:upper-1
(case cat-before
(:punct
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat))))
(if transformed-rest
(list* "+" part transformed-rest)
(list* "*" part (camel-case-transform rest cat)))))
(:numeric (list* "-*" part (camel-case-transform rest cat)))
(t (list* "-" part (camel-case-transform rest cat)))))
(:numeric
(case cat-before
(:punct
(let ((transformed-rest
(catch 'all-caps
(camel-case-transform-all-caps rest cat t))))
(if transformed-rest
(list* "+" part transformed-rest)
(cons part (camel-case-transform rest cat)))))
(t (list* "-" part (camel-case-transform rest cat)))))
(:mixed
(list* (case cat-before (:punct "*") (:numeric "-*") (t "-"))
(string-upcase part)
(camel-case-transform rest cat)))
(:lower
(list* (if (eql cat-before :punct) "" "-")
(string-upcase part)
(camel-case-transform rest cat)))
(:punct
(cons (if (string= part "_") "--" part)
(camel-case-transform rest cat)))))))
(defun camel-case-to-lisp (string)
"Take a camel-case string and convert it into a string with
Lisp-style hyphenation."
(apply #'concatenate 'string
(camel-case-transform (camel-case-split string))))
(defun lisp-to-camel-case (string)
"Take a string with Lisp-style hyphentation and convert it to camel
case. This is an inverse of CAMEL-CASE-TO-LISP."
(loop with i = 0 and l = (length string)
with cc-string = (make-string l) and cc-i = 0
with init = t and cap = nil and all-caps = nil
while (< i l)
do (let ((c (aref string i)))
(unless (case c
(#\* (if init (setq cap t)))
(#\+ (cond
(all-caps (setq all-caps nil init t))
(init (setq all-caps t))))
(#\- (progn
(setq init t)
(cond
((or all-caps
(and (< (1+ i) l)
(char= (aref string (1+ i)) #\-)
(incf i)))
(setf (aref cc-string cc-i) #\_)
(incf cc-i))
(t (setq cap t))))))
(setf (aref cc-string cc-i)
(if (and (or cap all-caps) (alpha-char-p c))
(char-upcase c)
(char-downcase c)))
(incf cc-i)
(setq cap nil init nil))
(incf i))
finally (return (subseq cc-string 0 cc-i))))
| 7,990 | Common Lisp | .lisp | 172 | 32.203488 | 76 | 0.501793 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 1a84af9cf58d2f42e7af33a2289662ab906c503edc6a1126944236103be61057 | 43,029 | [
308403
] |
43,030 | decoder.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/src/decoder.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10; Package: JSON -*-
;;;; Copyright (c) 2006-2008 Henrik Hjelte
;;;; All rights reserved.
;;;; See the file LICENSE for terms of use and distribution.
(in-package :json)
;;; Token reader
(define-condition json-syntax-error (simple-error stream-error)
((stream-file-position :reader stream-error-stream-file-position
:initarg :stream-file-position))
(:report
(lambda (condition stream)
(format stream "~? [in ~S~@[ at position ~D~]]"
(simple-condition-format-control condition)
(simple-condition-format-arguments condition)
(stream-error-stream condition)
(stream-error-stream-file-position condition))))
(:documentation
"Signalled when non-well-formed JSON data are encountered."))
(defun json-syntax-error (stream format-control &rest format-arguments)
"Signal a JSON-SYNTAX-ERROR condition."
(error 'json-syntax-error
:stream stream
:stream-file-position (file-position stream)
:format-control format-control
:format-arguments format-arguments))
(defun read-json-token (stream)
"Read a JSON token (literal name, number or punctuation char) from
the given STREAM, and return 2 values: the token category (a symbol)
and the token itself, as a string or character."
(let ((c (peek-char t stream)))
(case c
((#\{ #\[ #\] #\} #\" #\: #\,)
(values :punct (read-char stream)))
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 #\-)
(read-json-number-token stream))
(t (if (alpha-char-p c)
(read-json-name-token stream)
(json-syntax-error stream "Invalid char on JSON input: `~C'"
c))))))
(defun peek-json-token (stream)
"Return 2 values: the category and the first character of the next
token available in the given STREAM. Unlike READ-JSON-TOKEN, this
function can not discriminate between integers and reals (hence, it
returns a single :NUMBER category), and cannot check whether the next
available symbol is a valid boolean or not (hence, the category for
such tokens is :SYMBOL)."
(let ((c (peek-char t stream)))
(values
(case c
((#\{ #\[ #\] #\} #\" #\: #\,) :punct)
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 #\-) :number)
(t (if (alpha-char-p c)
:symbol
(json-syntax-error stream "Invalid char on JSON input: `~C'"
c))))
c)))
(defun read-json-number-token (stream)
"Read a JSON number token from the given STREAM, and return 2
values: the token category (:INTEGER or :REAL) and the token itself,
as a string."
(let* ((chars (cons nil nil))
(chars-tail chars)
(category :integer)
(c (read-char stream nil)))
(flet ((next-char ()
(setf chars-tail (setf (cdr chars-tail) (cons c nil))
c (read-char stream nil))))
(macrolet ((read-part (name divider &rest sign)
`(loop for part-length upfrom 0
initially
,@(if divider
`((if (and c (char-equal c ,divider))
(next-char)
(return))))
,@(if sign
(let ((sign
`(or ,@(loop for s in sign
collect `(char= c ,s)))))
`((if (and c ,sign) (next-char)))))
,@(if (eq name 'int)
`((when (and c (char= c #\0))
(next-char)
(return))))
while (and c (char<= #\0 c #\9))
do (next-char)
finally
,(let ((error-fmt
(format nil
"Invalid JSON number: no ~:(~A~) digits"
name)))
`(if (zerop part-length)
(json-syntax-error stream ,error-fmt)))
,@(unless (eq name 'int)
`((setq category :real))))))
(read-part Int nil #\-)
(read-part Frac #\.)
(read-part Exp #\e #\- #\+)
(if c (unread-char c stream))
(values category (coerce (cdr chars) 'string))))))
(defun read-json-name-token (stream)
"Read a JSON literal name token from the given STREAM, and return 2
values: the token category (:BOOLEAN) and the token itself, as a
string."
(let ((name
(loop for c = (read-char stream nil)
while (and c (alpha-char-p c))
collect c into chars
finally (if c (unread-char c stream))
(return (coerce chars 'string)))))
(if (assoc name +json-lisp-symbol-tokens+ :test #'equal)
(values :boolean name)
(json-syntax-error stream "Invalid JSON literal name: ~A"
name))))
(define-condition no-char-for-code (error)
((offending-code :initarg :code :reader offending-code))
(:report (lambda (condition stream)
(format stream "No character corresponds to code #x~4,'0X."
(offending-code condition))))
(:documentation
"Signalled when, in a JSON String, an escaped code point (\uXXXX)
is encountered which is greater than the application's CHAR-CODE-LIMIT
or for which CODE-CHAR returns NIL."))
(defmacro escaped-char-dispatch (char &key code-handler default-handler)
"Compiles the escaped character alist to a (CASE ...) match expression."
`(case ,char
,@(loop for (c . unescaped) in +json-lisp-escaped-chars+
if (characterp unescaped)
collect (list c unescaped)
else if (consp unescaped)
collect
(destructuring-bind ((len rdx) &body body) code-handler
(destructuring-bind (len-v . rdx-v) unescaped
`(,c (let ((,len ,len-v) (,rdx ,rdx-v)) ,@body)))))
(t ,default-handler)))
(defun read-json-string-char (stream)
"Read a JSON String char (or escape sequence) from the STREAM and
return it. If an end of string (unescaped quote) is encountered,
return NIL."
(let ((esc-error-fmt "Invalid JSON character escape sequence: ~A~A")
(c (read-char stream)))
(case c
(#\" nil) ; End of string
(#\\ (let ((c (read-char stream)))
(escaped-char-dispatch c
:code-handler
((len rdx)
(let ((code
(let ((repr (make-string len)))
(dotimes (i len)
(setf (aref repr i) (read-char stream)))
(handler-case (parse-integer repr :radix rdx)
(parse-error ()
(json-syntax-error stream esc-error-fmt
(format nil "\\~C" c)
repr))))))
(restart-case
(or (and (< code char-code-limit) (code-char code))
(error 'no-char-for-code :code code))
(substitute-char (char)
:report "Substitute another char."
:interactive
(lambda ()
(format *query-io* "Char: ")
(list (read-char *query-io*)))
char)
(pass-code ()
:report "Pass the code to char handler."
code))))
:default-handler
(if *use-strict-json-rules*
(json-syntax-error stream esc-error-fmt "\\" c)
c))))
(t c))))
;;; The decoder base
(defvar *json-input* (make-synonym-stream '*standard-input*)
"The default input stream for decoding operations.")
(define-custom-var (:integer *integer-handler*) (constantly 0)
"Designator for a function of 1 string argument (integer token).")
(define-custom-var (:real *real-handler*) (constantly 0)
"Designator for a function of 1 string argument (real token).")
(define-custom-var (:boolean *boolean-handler*) (constantly t)
"Designator for a function of 1 string argument (boolean token).")
(define-custom-var (:beginning-of-string *beginning-of-string-handler*)
(constantly t)
"Designator for a function of no arguments (called at encountering
an opening quote for a String).")
(define-custom-var (:string-char *string-char-handler*) (constantly t)
"Designator for a function of 1 character argument (String char).")
(define-custom-var (:end-of-string *end-of-string-handler*) (constantly "")
"Designator for a function of no arguments (called at encountering
a closing quote for a String).")
(define-custom-var (:beginning-of-array *beginning-of-array-handler*)
(constantly t)
"Designator for a function of no arguments (called at encountering
an opening bracket for an Array).")
(define-custom-var (:array-member *array-member-handler*) (constantly t)
"Designator for a function of 1 arbitrary argument (decoded member
of Array).")
(define-custom-var (:end-of-array *end-of-array-handler*) (constantly nil)
"Designator for a function of no arguments (called at encountering
a closing bracket for an Array).")
(define-custom-var (:array-type *json-array-type*) 'vector
"The Lisp sequence type to which JSON Arrays are to be coerced.")
(define-custom-var (:beginning-of-object *beginning-of-object-handler*)
(constantly t)
"Designator for a function of no arguments (called at encountering
an opening brace for an Object).")
(define-custom-var (:object-key *object-key-handler*) (constantly t)
"Designator for a function of 1 string argument (decoded member key
of Object).")
(define-custom-var (:object-value *object-value-handler*) (constantly t)
"Designator for a function of 1 arbitrary argument (decoded member
value of Object).")
(define-custom-var (:end-of-object *end-of-object-handler*)
(constantly nil)
"Designator for a function of no arguments (called at encountering
a closing brace for an Object).")
(define-custom-var (:internal-decoder *internal-decoder*) 'decode-json
"Designator for a function of 1 stream argument called (instead of
DECODE-JSON) to decode a member of an Array or of an Object.")
(define-custom-var (:object-scope *object-scope-variables*)
'(*internal-decoder*)
"A list of symbols naming dynamic variables which should be re-bound
in the scope of every JSON Object.")
(define-custom-var (:array-scope *array-scope-variables*)
'(*internal-decoder*)
"A list of symbols naming dynamic variables which should be re-bound
in the scope of every JSON Array.")
(define-custom-var (:string-scope *string-scope-variables*)
nil
"A list of symbols naming dynamic variables which should be re-bound
in the scope of every JSON String.")
(define-custom-var (:aggregate-scope *aggregate-scope-variables*)
nil
"A list of symbols naming dynamic variables which should be re-bound
in the scope of every JSON aggregate value (Object, Array or String).")
(defun decode-json (&optional (stream *json-input*))
"Read a JSON Value from STREAM and return the corresponding Lisp value."
(multiple-value-bind (dispatch-token-type dispatch-token)
(read-json-token stream)
(ecase dispatch-token-type
(:punct
(case dispatch-token
(#\" (decode-json-string stream))
(#\[ (decode-json-array stream))
(#\{ (decode-json-object stream))
(t (json-syntax-error stream
"Token out of place on JSON input: `~C'"
dispatch-token))))
(:integer (funcall *integer-handler* dispatch-token))
(:real (funcall *real-handler* dispatch-token))
(:boolean (funcall *boolean-handler* dispatch-token)))))
(defmacro custom-decoder (&rest customizations)
"Return a function which is like DECODE-JSON called in a dynamic
environment with the given CUSTOMIZATIONS."
`(lambda (&optional (stream *json-input*))
(bind-custom-vars ,customizations
(decode-json stream))))
(defun decode-json-from-string (json-string)
"Read a JSON Value from JSON-STRING and return the corresponding
Lisp value."
(with-input-from-string (stream json-string)
(decode-json stream)))
(defun decode-json-from-source (source &optional (decoder 'decode-json))
"Decode a JSON Value from SOURCE using the value of DECODER (default
'DECODE-JSON) as decoder function. If the SOURCE is a string, the
input is from this string; if it is a pathname, the input is from the
file that it names; otherwise, a stream is expected as SOURCE."
(etypecase source
(pathname
(with-open-file (s source) (funcall decoder s)))
(string
(with-input-from-string (s source) (funcall decoder s)))
(stream (funcall decoder source))))
(defun decode-json-strict (&optional (stream *json-input*))
"Same as DECODE-JSON, but allow only Objects or Arrays on the top
level, no junk afterwards."
(assert (member (peek-char t stream) '(#\{ #\[)))
(let ((object (decode-json stream)))
(assert (eq :no-junk (peek-char t stream nil :no-junk)))
object))
(defmacro aggregate-scope-progv (variables &body body)
"Establish a dynamic environment where all VARIABLES are freshly
bound (to their current values), and execute BODY in it, returning the
result."
`(progv ,variables (mapcar #'symbol-value ,variables)
,@body))
(defun decode-json-array (stream)
"Read comma-separated sequence of JSON Values until a closing bracket,
calling array handlers as it goes."
(aggregate-scope-progv *array-scope-variables*
(aggregate-scope-progv *aggregate-scope-variables*
(funcall *beginning-of-array-handler*)
(multiple-value-bind (type token) (peek-json-token stream)
(if (and (eql type :punct) (char= token #\]))
(progn
(read-json-token stream)
(return-from decode-json-array
(funcall *end-of-array-handler*)))
(funcall *array-member-handler*
(funcall *internal-decoder* stream))))
(loop
(multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\] (return-from decode-json-array
(funcall *end-of-array-handler*)))
(#\, (setq token nil))))
(if token
(json-syntax-error
stream
"Token out of place in Array on JSON input: `~A'"
token)))
(funcall *array-member-handler*
(funcall *internal-decoder* stream))))))
(defun decode-json-object (stream)
"Read comma-separated sequence of JSON String:Value pairs until a
closing brace, calling object handlers as it goes."
(aggregate-scope-progv *object-scope-variables*
(aggregate-scope-progv *aggregate-scope-variables*
(loop with key = nil and expect-key = t
for first-time-p = t then nil
initially (funcall *beginning-of-object-handler*)
do (multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\}
(if first-time-p
(return-from decode-json-object
(funcall *end-of-object-handler*))))
(#\"
(setq key (decode-json-string stream)
expect-key nil))))
(if expect-key
(json-syntax-error
stream
"Expected a key String in Object on JSON input ~
but found `~A'"
token)
(funcall *object-key-handler* key)))
(multiple-value-bind (type token) (read-json-token stream)
(unless (and (eql type :punct) (char= token #\:))
(json-syntax-error
stream
"Expected a `:' separator in Object on JSON input ~
but found `~A'"
token)))
(funcall *object-value-handler*
(funcall *internal-decoder* stream))
(multiple-value-bind (type token) (read-json-token stream)
(if (eql type :punct)
(case token
(#\} (return-from decode-json-object
(funcall *end-of-object-handler*)))
(#\, (setq key nil expect-key t))))
(if (not expect-key)
(json-syntax-error
stream
"Expected a `,' separator or `}' in Object on JSON ~
input but found `~A'"
token)))))))
(defun decode-json-string (stream)
"Read JSON String characters / escape sequences until a closing
double quote, calling string handlers as it goes."
(aggregate-scope-progv *string-scope-variables*
(aggregate-scope-progv *aggregate-scope-variables*
(loop initially (funcall *beginning-of-string-handler*)
for c = (read-json-string-char stream)
while c
do (funcall *string-char-handler* c)
finally (return (funcall *end-of-string-handler*))))))
;;; handling numerical read errors in ACL
#+allegro
(defun allegro-read-numerical-overflow-p (condition)
(and (typep condition 'simple-error)
(search "is too large to be converted"
(slot-value condition 'excl::format-control))))
#+allegro
(deftype allegro-reader-numerical-overflow ()
`(and error (satisfies allegro-read-numerical-overflow-p)))
;;; The default semantics
(defun parse-number (token)
"Take a number token and convert it to a numeric value."
;; We can be reasonably sure that nothing but well-formed (both in
;; JSON and Lisp sense) number literals get to this point.
(flet ((floatify (x)
(float x
(ecase *read-default-float-format*
(short-float 1.0s0)
(single-float 1.0)
(double-float 1.0d0)
(long-float 1.0l0)))))
(let* ((negated (char-equal #\- (aref token 0)))
(token (string-left-trim '(#\-) token)))
(let ((f-marker (position #\. token :test #'char-equal))
(e-marker (position #\e token :test #'char-equal)))
(if (or e-marker f-marker)
(let* ((int-part
(subseq token 0 (or f-marker e-marker)))
(frac-part
(if f-marker
(subseq token (1+ f-marker) e-marker)
"0"))
(significand
(+ (parse-integer int-part)
(* (parse-integer frac-part)
(expt 10 (- (length frac-part))))))
(exponent
(if e-marker
(parse-integer (subseq token (1+ e-marker)))
0)))
(restart-case
;; FIXME: the below have to be double-float when that's the value of
;; *read-default-float-format*: short-float, single-float, double-float, long-float
(let ((value
(* (floatify significand) (expt 10 (floatify exponent)))))
(if negated
(- value)
value))
(bignumber-string (&optional (prefix "BIGNUMBER:"))
:report "Return the number token prefixed as big number."
(concatenate 'string (if negated "-" "") prefix token))
(rational-approximation ()
:report "Use rational instead of float."
(let ((rat
(* significand (expt 10 exponent))))
(if negated (- rat) rat)))
(placeholder (value)
:report "Return a user-supplied placeholder value."
value)))
(let ((int (parse-integer token)))
(if negated (- int) int)))))))
(defun json-boolean-to-lisp (token)
"Take a literal name token and convert it to a boolean value."
;; We can be reasonably sure that nothing but well-formed boolean
;; literals get to this point.
(cdr (assoc token +json-lisp-symbol-tokens+ :test #'string=)))
(defvar *accumulator* nil
"List or vector where elements are stored.")
(defvar *accumulator-last* nil
"If *ACCUMULATOR* is a list, this refers to its last cons.")
(defun init-accumulator ()
"Initialize a list accumulator."
(let ((head (cons nil nil)))
(setq *accumulator* head)
(setq *accumulator-last* head)))
(defun accumulator-add (element)
"Add ELEMENT to the end of the list accumulator."
(setq *accumulator-last*
(setf (cdr *accumulator-last*) (cons element nil))))
(defun accumulator-add-key (key)
"Add a cons whose CAR is KEY to the end of the list accumulator."
(let ((key (funcall *identifier-name-to-key* (funcall *json-identifier-name-to-lisp* key))))
(setq *accumulator-last*
(setf (cdr *accumulator-last*) (cons (cons key nil) nil)))))
(defun accumulator-add-value (value)
"Set the CDR of the most recently accumulated cons to VALUE."
(setf (cdar *accumulator-last*) value)
*accumulator-last*)
(defun accumulator-get-sequence ()
"Return all values accumulated so far in the list accumulator as
*JSON-ARRAY-TYPE*."
(coerce (cdr *accumulator*) *json-array-type*))
(defun accumulator-get-string ()
"Return all values accumulated so far in the list accumulator as
*JSON-ARRAY-TYPE*."
(coerce (cdr *accumulator*) 'string))
(defun accumulator-get ()
"Return all values accumulated so far in the list accumulator as a
list."
(cdr *accumulator*))
(defun init-string-stream-accumulator ()
"Initialize a string-stream accumulator."
(setq *accumulator* (make-string-output-stream)))
(defun string-stream-accumulator-add (char)
"Add CHAR to the end of the string-stream accumulator."
(write-char char *accumulator*)
*accumulator*)
(defun string-stream-accumulator-get ()
"Return all characters accumulated so far in a string-stream
accumulator and close the stream."
(prog1 (get-output-stream-string *accumulator*)
(close *accumulator*)))
(defun set-decoder-simple-list-semantics ()
"Set the decoder semantics to the following:
* Strings and Numbers are decoded naturally, reals becoming floats.
* The literal name true is decoded to T, false and null to NIL.
* Arrays are decoded to sequences of the type *JSON-ARRAY-TYPE*.
* Objects are decoded to alists. Object keys are converted by the
function *JSON-IDENTIFIER-NAME-TO-LISP* and then interned in the
package *JSON-SYMBOLS-PACKAGE*."
(set-custom-vars
:integer #'parse-number
:real #'parse-number
:boolean #'json-boolean-to-lisp
:beginning-of-array #'init-accumulator
:array-member #'accumulator-add
:end-of-array #'accumulator-get-sequence
:array-type 'list
:beginning-of-object #'init-accumulator
:object-key #'accumulator-add-key
:object-value #'accumulator-add-value
:end-of-object #'accumulator-get
:beginning-of-string #'init-string-stream-accumulator
:string-char #'string-stream-accumulator-add
:end-of-string #'string-stream-accumulator-get
:aggregate-scope (union *aggregate-scope-variables*
'(*accumulator* *accumulator-last*))
:internal-decoder #'decode-json))
(defmacro with-decoder-simple-list-semantics (&body body)
"Execute BODY in a dynamic environement where the decoder semantics
is such as set by SET-DECODER-SIMPLE-LIST-SEMANTICS."
`(with-shadowed-custom-vars
(set-decoder-simple-list-semantics)
,@body))
;;; The CLOS semantics
#+cl-json-clos (progn
(defvar *prototype-prototype*
(make-instance 'prototype
:lisp-class 'prototype
:lisp-package :json)
"The prototype for a prototype object.")
(defvar *prototype* nil
"When NIL, the Object being decoded does not (yet?) have a prototype.
When T, the decoder should get ready to decode a prototype field.
Otherwise, the value should be a prototype for the object being decoded.")
(defun init-accumulator-and-prototype ()
"Initialize a list accumulator and a prototype."
(init-accumulator)
(if (eql *prototype* t)
(setq *prototype* *prototype-prototype*
*json-array-type* 'list)
(setq *prototype* nil)))
(defun accumulator-add-key-or-set-prototype (key)
"If KEY (in a JSON Object being decoded) matches *PROTOTYPE-NAME*,
prepare to decode the corresponding Value as a PROTOTYPE object.
Otherwise, do the same as ACCUMULATOR-ADD-KEY."
(let ((key (funcall *json-identifier-name-to-lisp* key)))
(if (and (not *prototype*)
*prototype-name*
(string= key (symbol-name *prototype-name*)))
(setq *prototype* t)
(setq *accumulator-last*
(setf (cdr *accumulator-last*) (cons (cons key nil) nil))))
*accumulator*))
(defun accumulator-add-value-or-set-prototype (value)
"If VALUE (in a JSON Object being decoded) corresponds to a key
which matches *PROTOTYPE-NAME*, set VALUE to be the prototype of the
Object. Otherwise, do the same as ACCUMULATOR-ADD-VALUE."
(if (eql *prototype* t)
(progn
(check-type value (or prototype string)
(format nil "Invalid prototype: ~S." value))
(setq *prototype* value)
*accumulator*)
(accumulator-add-value value)))
(defun accumulator-get-object ()
"Return a CLOS object, using keys and values accumulated so far in
the list accumulator as slot names and values, respectively. If the
JSON Object had a prototype field infer the class of the object and
the package wherein to intern slot names from the prototype.
Otherwise, create a FLUID-OBJECT with slots interned in
*JSON-SYMBOLS-PACKAGE*."
(flet ((as-symbol (value)
(etypecase value
(string (funcall *identifier-name-to-key*
(funcall *json-identifier-name-to-lisp* value)))
(symbol value)))
(intern-keys (bindings)
(loop for (key . value) in bindings
collect (cons (funcall *identifier-name-to-key* key) value))))
(if (typep *prototype* 'prototype)
(with-slots (lisp-class lisp-superclasses lisp-package)
*prototype*
(let* ((package-name (as-symbol lisp-package))
(*json-symbols-package*
(if package-name
(or (find-package package-name)
(error 'package-error :package package-name))
*json-symbols-package*))
(class (as-symbol lisp-class))
(superclasses (mapcar #'as-symbol lisp-superclasses)))
(maybe-add-prototype
(make-object (intern-keys (cdr *accumulator*))
class superclasses)
*prototype*)))
(let ((bindings (intern-keys (cdr *accumulator*)))
(class (if (stringp *prototype*) (as-symbol *prototype*))))
(if (and *prototype* (not class))
(push (cons *prototype-name* *prototype*) bindings))
(make-object bindings class)))))
(defun set-decoder-simple-clos-semantics ()
"Set the decoder semantics to the following:
* Strings and Numbers are decoded naturally, reals becoming floats.
* The literal name true is decoded to T, false and null to NIL.
* Arrays are decoded to sequences of the type *JSON-ARRAY-TYPE*.
* Objects are decoded to CLOS objects. Object keys are converted by
the function *JSON-IDENTIFIER-NAME-TO-LISP*. If a JSON Object has a
field whose key matches *PROTOTYPE-NAME*, the class of the CLOS object
and the package wherein to intern slot names are inferred from the
corresponding value which must be a valid prototype. Otherwise, a
FLUID-OBJECT is constructed whose slot names are interned in
*JSON-SYMBOLS-PACKAGE*."
(set-custom-vars
:integer #'parse-number
:real #'parse-number
:boolean #'json-boolean-to-lisp
:beginning-of-array #'init-accumulator
:array-member #'accumulator-add
:end-of-array #'accumulator-get-sequence
:array-type 'vector
:beginning-of-object #'init-accumulator-and-prototype
:object-key #'accumulator-add-key-or-set-prototype
:object-value #'accumulator-add-value-or-set-prototype
:end-of-object #'accumulator-get-object
:beginning-of-string #'init-string-stream-accumulator
:string-char #'string-stream-accumulator-add
:end-of-string #'string-stream-accumulator-get
:aggregate-scope (union *aggregate-scope-variables*
'(*accumulator* *accumulator-last*))
:object-scope (union *object-scope-variables*
'(*prototype* *json-array-type*))
:internal-decoder #'decode-json))
(defmacro with-decoder-simple-clos-semantics (&body body)
"Execute BODY in a dynamic environement where the decoder semantics
is such as set by SET-DECODER-SIMPLE-CLOS-SEMANTICS."
`(with-shadowed-custom-vars
(set-decoder-simple-clos-semantics)
,@body))
) ; #+cl-json-clos
;;; List semantics is the default.
(set-decoder-simple-list-semantics)
;;; Shallow overriding of semantics.
(defmacro current-decoder (&rest keys)
"Capture current values of custom variables and return a custom
decoder which restores these values in its dynamic environment."
(let (exterior-bindings customizations)
(flet ((collect (key var)
(let ((exterior (gensym)))
(push (list exterior var) exterior-bindings)
(push exterior customizations)
(push key customizations))))
(if keys
(loop for key in keys
do (collect key (custom-key-to-variable key)))
(loop-on-custom (key var)
do (collect key var)))
`(let ,exterior-bindings
(custom-decoder ,@customizations)))))
(defmacro with-custom-decoder-level ((&rest customizations) &body body)
"Execute BODY in a dynamic environment such that, when nested
structures are decoded, the outermost level is decoded with the given
custom handlers (CUSTOMIZATIONS) whereas inner levels are decoded in
the usual way."
`(let ((current-decoder
(current-decoder
,@(loop for (key value) on customizations by #'cddr
if (eq key :internal-decoder)
do (error "~S ~S customization is meaningless in ~
the context of WITH-CUSTOM-DECODER-LEVEL."
key value)
else collect key))))
(bind-custom-vars (:internal-decoder current-decoder ,@customizations)
,@body)))
| 31,135 | Common Lisp | .lisp | 664 | 37.274096 | 101 | 0.614788 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | aa1f0287820e482e8a8b0a77245e8453db0b4b3173edeb3a3c71c58e2d05b415 | 43,030 | [
210756
] |
43,031 | package.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/t/package.lisp | (defpackage :json-test
(:use :json :json-rpc :common-lisp :5am )
#+cl-json-clos
(:import-from #+(or mcl openmcl) #:ccl
#+cmu #:clos-mop
#+sbcl #:sb-mop
#+(or clisp ecl scl lispworks) #:clos
#+(or allegro abcl) #:mop
#+genera #:clos-internals
#:finalize-inheritance))
(in-package :json-test)
(def-suite json)
| 385 | Common Lisp | .lisp | 12 | 24.666667 | 53 | 0.55914 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c9615771f330e7efcd78d9dfa158e63817642c3f109df81941383b3addef5c1a | 43,031 | [
110938
] |
43,032 | testjson.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/t/testjson.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base:10; Package: JSON-TEST -*-
(in-package :json-test)
(run! 'json)
| 116 | Common Lisp | .lisp | 3 | 37.666667 | 78 | 0.646018 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 8f746e43e6a58d94c962a49c4d67c91d6811817f33954a5637ae0a376cf1ccac | 43,032 | [
401259
] |
43,033 | testencoder.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/t/testencoder.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base:10; Package: JSON-TEST -*-
(in-package :json-test)
(in-suite json)
(defmacro with-objects-as-hashtables (&body body)
;;For testing, keys are stored as strings
(let ((ht (gensym)) (key (gensym)))
`(let (,ht ,key)
(declare (special ,ht ,key))
(json:bind-custom-vars
(:beginning-of-object #'(lambda () (setq ,ht (make-hash-table :test #'equalp)))
:object-key #'(lambda (key) (setq ,key key))
:object-value #'(lambda (value) (setf (gethash ,key ,ht) value))
:end-of-object #'(lambda () ,ht)
:object-scope '(,ht ,key))
,@body))))
(test json-string()
(is (string= (encode-json-to-string (format nil "hello~&hello"))
"\"hello\\nhello\""))
(is (string= (encode-json-to-string (format nil "\"aquote"))
"\"\\\"aquote\"")))
(test json-literals
(is (string= "true" (encode-json-to-string t)))
(is (string= "null" (encode-json-to-string nil))))
(defun is-same-number(nr)
"If it gets decoded back ok then it was encoded ok"
(is (= nr (decode-json-from-string (encode-json-to-string nr)))))
(test json-number
(is (string= "0" (encode-json-to-string 0)))
(is (string= "13" (encode-json-to-string 13)))
(is (string= "13.02" (encode-json-to-string 13.02)))
(is (string= "13.02" (encode-json-to-string 13.02D0)))
(is (string= "13.02" (encode-json-to-string 13.02L0)))
(is (string= "13.02" (encode-json-to-string 13.02S0)))
(is (string= "13.02" (encode-json-to-string 13.02E0)))
(is-same-number 2e10)
(is-same-number -1.3234e-10)
(is-same-number -1280.12356)
(is-same-number 1d2)
(is-same-number 1l2)
(is-same-number 1s2)
(is-same-number 1f2)
(is-same-number 1e2))
(defun decode-then-encode (json)
(with-objects-as-hashtables
(assert (member (elt json 0) '(#\{ #\[ #\" ))) ;must be json
(flet ((normalize (string)
(remove #\Newline (remove #\Space string))))
(let* ((decoded (decode-json-from-string json))
(encoded (encode-json-to-string decoded)))
;; (format t "Decoded:~a~&" decoded)
;; (format t "Encoded:~a" encoded)
(is (string= (normalize json)
(normalize encoded)))))))
(test test-encode-json-nathan-hawkins
(let ((foo '((a . 1) (b . 2) (c . 3))))
(is (string= (encode-json-to-string foo)
"{\"a\":1,\"b\":2,\"c\":3}"))))
(test test-encode-json-alist
(let ((alist `((:HELLO . 100)(:hi . 5)))
(expected "{\"hello\":100,\"hi\":5}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
(test test-encode-json-alist-two
(let ((alist `((HELLO . 100)(hi . 5)))
(expected "{\"hello\":100,\"hi\":5}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
(test test-encode-json-alist-nested
(let ((alist `((:hello . 100)(:hi . ((:a . 1)
(:b . 2)))))
(expected "{\"hello\":100,\"hi\":{\"a\":1,\"b\":2}}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
(test test-encode-json-alist-string
(let ((alist `((:hello . "hej")(:hi . "tjena")))
(expected "{\"hello\":\"hej\",\"hi\":\"tjena\"}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
(test test-encode-json-alist-camel-case
(let ((alist `((:hello-message . "hej")(*also-starting-with-upper . "hej")))
(expected "{\"helloMessage\":\"hej\",\"AlsoStartingWithUpper\":\"hej\"}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
(test test-encode-json-alist-embedded-nil
;; It makes construction easier in some cases, such as this:
(let ((alist `((:hello . "england")
,(when nil
'(:ciao . "italy"))
(:hej . "sweden")))
(expected "{\"hello\":\"england\",\"hej\":\"sweden\"}"))
(is (string= (with-output-to-string (s) (encode-json-alist alist s))
expected))))
;;; Invalidated by the patch ``Various modifications, mostly concerning
;;; the encoder.'' (Wed Jan 21 18:34:49 MSK 2009)
;
; (test test-encode-json-alist-with-prototype
; (let ((alist `((hello . 100) (hi . 5)))
; (expected "{\"hello\":100,\"hi\":5,\"prototype\":{\"lispClass\":\"cons\",\"lispSuperclasses\":null,\"lispPackage\":\"jsonTest\"}}")
; (*prototype-name* 'prototype))
; (is (string= (encode-json-to-string alist) expected))))
(test test-encode-json-plist
(let ((plist '(:foo 1 :bar "blub"))
(expected "{\"foo\":1,\"bar\":\"blub\"}"))
(is (string= (with-output-to-string (s) (encode-json-plist plist s))
expected))
(is (string= (encode-json-plist-to-string plist)
expected))))
(test encode-pass-2
(decode-then-encode "[[[[[[[[[[[[[[[[[[[\"Not too deep\"]]]]]]]]]]]]]]]]]]]"))
(test encode-pass-3
(decode-then-encode "{
\"JSON Test Pattern pass3\": {
\"The outermost value\": \"must be an object or array.\"
}
}
"))
(defclass foo () ((bar :initarg :bar) (baz :initarg :baz)))
(defclass goo () ((quux :initarg :quux :initform 933)))
(defclass frob (foo goo) ())
#+cl-json-clos
(test test-encode-json-clos
(finalize-inheritance (find-class 'goo))
(let ((obj (make-instance 'foo
:bar (json:make-object '((hello . 100) (hi . 5))
nil '(goo))
:baz (make-instance 'frob
:bar 'xyzzy
:baz (make-instance 'fluid-object))))
(expected "{\"bar\":{\"quux\":933,\"hello\":100,\"hi\":5},\"baz\":{\"quux\":933,\"bar\":\"xyzzy\",\"baz\":{}}}"))
(is (string= (encode-json-to-string obj) expected))))
;;; Invalidated by the patch ``Various modifications, mostly concerning
;;; the encoder.'' (Wed Jan 21 18:34:49 MSK 2009)
;
; (test test-encode-json-clos-with-prototype
; (finalize-inheritance (find-class 'goo))
; (let ((obj (make-instance 'foo
; :bar (json:make-object '((hello . 100) (hi . 5))
; nil '(goo))
; :baz (make-instance 'frob :bar 'xyzzy :baz 'blub)))
; (expected "{\"bar\":{\"quux\":933,\"hello\":100,\"hi\":5,\"prototype\":{\"lispClass\":null,\"lispSuperclasses\":[\"goo\"],\"lispPackage\":\"jsonTest\"}},\"baz\":{\"quux\":933,\"bar\":\"xyzzy\",\"baz\":\"blub\",\"prototype\":{\"lispClass\":\"frob\",\"lispSuperclasses\":null,\"lispPackage\":\"jsonTest\"}},\"prototype\":{\"lispClass\":\"foo\",\"lispSuperclasses\":null,\"lispPackage\":\"jsonTest\"}}")
; (*prototype-name* 'prototype))
; (is (string= (encode-json-to-string obj) expected))))
#.(export 'json::emotional (find-package '#:json))
#+cl-json-clos
(test test-encode-json-clos-max-package
(let ((obj (json:make-object
`((rational . 100) (emotional . 5)
(prototype . ,(json:make-object-prototype nil '(rational emotional prototype))))
nil))
(expected "{\"rational\":100,\"emotional\":5,\"prototype\":{\"lispClass\":null,\"lispSuperclasses\":null,\"lispPackage\":\"json\"}}"))
(is (string= (with-output-to-string (s) (encode-json obj s))
expected))))
;; Test inspired by the file pass1.
;; There are too many small differences just to decode-encode the whole pass1 file,
;; Instead the difficult parts are in separate tests below.
(test controls
(decode-then-encode "\"\\\\b\\\\f\\\\n\\\\r\\\\\""))
(test slash
(let* ((z "\"/ & /\"")
(also-z "\"/ & \/\"") ;Extra quote
(x (encode-json-to-string z))
(also-x (encode-json-to-string also-z))
(y (decode-json-from-string x))
(also-y (decode-json-from-string also-x)))
(is (string= x also-x))
(is (string= y also-y))
(is (string= z y))))
(test quoted
(decode-then-encode "\"" %22 0x22 034 "\""))
(test alpha-1
(decode-then-encode "\"abcdefghijklmnopqrstuvwyz\""))
(test alpha-2
(decode-then-encode "\"ABCDEFGHIJKLMNOPQRSTUVWYZ\""))
(test digit
(decode-then-encode "\"0123456789\""))
(test special
(decode-then-encode "\"`1~!@#$%^&*()_+-={':[,]}|;.<>?\""))
(test hex
(decode-then-encode "\"\u0123\u4567\u89AB\uCDEF\uabcd\uef4A\""))
(test true
(decode-then-encode "[ true]"))
(test false
(is (string= (encode-json-to-string (decode-json-from-string "[false]"))
"[null]")));;We dont separate between false and null
(test null
(decode-then-encode "[null]"))
(test array
(with-decoder-simple-list-semantics
;;Since empty lists becomes nil in lisp, they are converted back to null
(is (string= (encode-json-to-string (decode-json-from-string "[ ]"))
"null")))
#+cl-json-clos
(with-decoder-simple-clos-semantics
;;Since empty lists becomes #() in lisp, they are converted back to empty list
(is (string= (encode-json-to-string (decode-json-from-string "[ ]"))
"[]")))
;;But you can use vectors
(is (string= (encode-json-to-string (vector 1 2))
"[1,2]")))
(test character
;;Characters are encoded to strings, but when decoded back to string
(is (string= (encode-json-to-string #\a) "\"a\"")))
(test hash-table-symbol
(let ((ht (make-hash-table)))
(setf (gethash 'symbols-are-now-converted-to-camel-case ht) 5)
(is (string= (encode-json-to-string ht)
"{\"symbolsAreNowConvertedToCamelCase\":5}"))))
;;; Invalidated by the patch ``Various modifications, mostly concerning
;;; the encoder.'' (Wed Jan 21 18:34:49 MSK 2009)
;
; (test hash-table-symbol-with-prototype
; (let ((ht (make-hash-table))
; (*prototype-name* 'prototype))
; (setf (gethash 'five ht) 5)
; (is (string= (encode-json-to-string ht)
; "{\"five\":5,\"prototype\":{\"lispClass\":\"hashTable\",\"lispSuperclasses\":null,\"lispPackage\":\"jsonTest\"}}"))))
(test hash-table-string
(let ((ht (make-hash-table :test #'equal)))
(setf (gethash "lower x" ht) 5)
(is (string= (encode-json-to-string ht)
"{\"lower x\":5}"))))
(defparameter *encode-performace-test-string*
"{
\"JSON Test Pattern pass3\": {
\"The outermost value\": \"must be an object or array.\",
\"In this test\": \"It is an object.\",
\"Performance-1\" : 123465.578,
\"Performance-2\" : 12e4,
\"Performance-2\" : \"asdasdsadsasdasdsdasdasdasdsaaaaaaaaaaaaasdasdasdasdasdsd\",
\"Performance-3\" : [\"asdasdsadsasdasdsdasdasdasdsaaaaaaaaaaaaasdasdasdasdasdsd\",
\"asdasdsadsasdasdsdasdasdasdsaaaaaaaaaaaaasdasdasdasdasdsd\",
\"asdasdsadsasdasdsdasdasdasdsaaaaaaaaaaaaasdasdasdasdasdsd\",
\"asdasdsadsasdasdsdasdasdasdsaaaaaaaaaaaaasdasdasdasdasdsd\"]
}
}
")
(test encoder-performance
(with-objects-as-hashtables
(let* ((json-string *encode-performace-test-string*)
(chars (length json-string))
(lisp-obj (decode-json-from-string json-string))
(count 2000))
(format t "Encoding ~a varying chars from memory ~a times." chars count)
(time
(dotimes (x count)
(let ((discard-soon (encode-json-to-string lisp-obj)))
(funcall #'identity discard-soon)))))))
(test streaming-encoder
(defpackage json-test-foo
(:use)
(:export #:bar #:baz #:quux))
(defpackage json-test-greek
(:use)
(:export #:lorem #:ipsum #:dolor #:sit #:amet))
(let* ((encoded
(with-output-to-string (out)
(with-object (out)
(with-input-from-string (in "json-test-foo json-test-greek")
(loop for pkgname = (read in nil) while pkgname
do (as-object-member (pkgname out)
(with-array (out)
(do-symbols (sym (find-package pkgname))
(encode-array-member sym out)))))))))
(package-alist
(with-decoder-simple-list-semantics
(let ((*json-symbols-package* 'json-test))
(decode-json-from-string encoded))))
(foo-symbols
(cdr (assoc 'json-test-foo package-alist)))
(greek-symbols
(cdr (assoc 'json-test-greek package-alist))))
(flet ((same-string-sets (a b)
(null (set-exclusive-or a b :test #'string-equal))))
(is (same-string-sets foo-symbols '("BAR" "BAZ" "QUUX")))
(is (same-string-sets greek-symbols '("LOREM" "IPSUM" "DOLOR" "SIT" "AMET"))))))
(test explicit-encoder
(is (string= "true" (with-explicit-encoder
(encode-json-to-string '(:true))))
"True")
(is (string= "false"
(with-explicit-encoder
(encode-json-to-string '(:false))))
"False")
(is (string= "null"
(with-explicit-encoder
(encode-json-to-string '(:null))))
"False")
(is (string= "[1,\"a\"]"
(with-explicit-encoder
(encode-json-to-string '(:list 1 "a"))))
"List")
(is (string= "[1,\"a\"]"
(with-explicit-encoder
(encode-json-to-string '(:array 1 "a"))))
"Array")
(is (string= "{\"a\":1,\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object "a" 1 "b" 2))))
"Plist")
(is (string= "{\"a\":1,\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object ("a" . 1) ( "b" . 2)))))
"Alist")
(is (string= "{\"a\":1,\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:alist ("a" . 1) ( "b" . 2)))))
"Explicit Alist")
(is (string= "{\"a\":1,\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:plist "a" 1 "b" 2))))
"Explicit Plist")
(is (string= "{\"a\":{\"c\":1,\"d\",2},\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object
"a" (:json "{\"c\":1,\"d\",2}")
"b" 2))))
"Embedded json")
(is (string= "{\"a\":{\"c\":1,\"d\":2},\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object
"a" (:object "c" 1 "d" 2)
"b" 2))))
"Object in object")
(is (string= "{\"a\":{\"c\":1,\"d\":2},\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object
"a" (:object ( "c" . 1) ( "d" . 2))
"b" 2))))
"Mixed alist and plist")
(is (string= "{\"a\":1,\"b\":2}"
(with-explicit-encoder
(encode-json-to-string '(:object ("a" . 1) nil ( "b" . 2)))))
"Alist with a nil value"))
(test explicit-encoder-complex-objects
(let ((sample-1-alists
`(:object
(:method . some-function)
(:id . 1)
(:params .
(:list
(:object (:id . bar-id)
(:name . bar))
(:true)
(:list (:object
(:name . a)
(:id . b)))
(:list (:object
(:name . foo)
(:id . foo-id)))
))))
(sample-2-plists
`(:object
:method some-function
:id 1
:params (:list
(:json "{\"id\":\"barId\",\"name\":\"bar\"}")
(:true)
(:list (:object "name" a :id b))
(:list (:object
:name foo
:id foo-id))
)))
(correct-json "
{\"method\":\"someFunction\",
\"id\":1,\"params\":
[{\"id\":\"barId\",\"name\":\"bar\"},
true,
[{\"name\":\"a\",\"id\":\"b\"}],
[{\"name\":\"foo\",\"id\":\"fooId\"}]]}")
exact-json sample-1-json sample-2-json)
(setf sample-1-json
(with-explicit-encoder
(encode-json-to-string sample-1-alists)))
(setf sample-2-json
(with-explicit-encoder
(encode-json-to-string sample-2-plists)))
(is (string= sample-1-json sample-2-json))
(setf exact-json (remove #\Newline
(remove #\Space correct-json :test #'char=)
:test #'char=))
(is (string= sample-1-json exact-json))))
(test json-bool
(is (equal (json-bool t) '(:true)))
(is (equal (json-bool 1) '(:true)))
(is (equal (json-bool nil) '(:false))))
(test json-or-null
(is (equal (json-or-null 'something) 'something))
(is (equal (json-or-null '(:list)) '(:list)))
(is (equal (json-or-null nil) '(:null)))
(is (equal (json-or-null (when t '(:list)))
'(:list)))
(is (equal (json-or-null (when nil '(:list)))
'(:null))))
(test sample-explict-decoder-building-with-json-bool
(labels
((foo-p (thing)
(eq thing 'foo))
(bar-p (thing)
(eq thing 'bar))
(foo-bar (thing)
(when (foo-p thing)
(cons :foo-bar "FUBAR!")))
(bar-json ()
"{\"bar\":true}")
(get-json (thing)
(with-explicit-encoder
(encode-json-to-string
`(:object :method foo-bar-check :id 0
:params (:object
(:bar . (:json ,(bar-json)))
(:is-foo . ,(json-bool (foo-p thing)))
(:is-bar . ,(json-bool (bar-p thing)))
,(foo-bar thing)))))))
(let ((json-foo (get-json 'foo))
(json-bar (get-json 'bar)))
(is (string= json-foo
"{\"method\":\"fooBarCheck\",\"id\":0,\"params\":{\"bar\":{\"bar\":true},\"isFoo\":true,\"isBar\":false,\"fooBar\":\"FUBAR!\"}}"))
(is (string= json-bar
"{\"method\":\"fooBarCheck\",\"id\":0,\"params\":{\"bar\":{\"bar\":true},\"isFoo\":false,\"isBar\":true}}")))))
| 18,546 | Common Lisp | .lisp | 419 | 34.73031 | 410 | 0.523356 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 906b0b8b119356d9844fe8303f5568b11dd84e3255c86d7614181f3468a656cb | 43,033 | [
136778
] |
43,034 | testdecoder.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/t/testdecoder.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base:10; Package: JSON-TEST -*-
(in-package :json-test)
(in-suite json)
;; Test decoder
(defun make-json-array-type (&rest elements)
(map json:*json-array-type* #'identity elements))
(test json-literal
(is-true (decode-json-from-string " true"))
(is-true (decode-json-from-string " true "))
(is-true (decode-json-from-string "true "))
(is-true (decode-json-from-string "true"))
;;; Invalidated by the patch ``Moved the customizable decoder
;;; (special-vars flavour) over to the main branch.'' (Thu Dec 4
;;; 22:02:02 MSK 2008). This is indeed an error situation, not one
;;; where a false value may be legally returned.
; (is-false (decode-json-from-string "trUe "))
(is-false (decode-json-from-string "false"))
(is-false (decode-json-from-string "null"))
)
(test json-string
(is (string= "hello"
(decode-json-from-string " \"hello\"")))
(is (string= "new-line
returned!"
(decode-json-from-string "\"new-line\\nreturned!\"")))
(is (string= (make-string 1 :initial-element (code-char (+ (* 10 16) 11)))
(decode-json-from-string " \"\\u00ab\""))))
(test json-array
(is (equalp
(make-json-array-type "hello" "hej" "ciao")
(decode-json-from-string " [ \"hello\", \"hej\",
\"ciao\" ]")))
(is (equalp (make-json-array-type 1 2 3)
(decode-json-from-string "[1,2,3]")))
(is (equalp (make-json-array-type t nil nil)
(decode-json-from-string "[true,null,false]")))
(is (equalp (make-json-array-type)
(decode-json-from-string "[]"))))
#+cl-json-clos
(defgeneric equal-objects-p (object1 object2)
(:method (object1 object2)
(equalp object1 object2))
(:method ((object1 standard-object) (object2 standard-object))
(let ((class1 (class-of object1))
(class2 (class-of object2)))
(and (eql class1 class2)
(loop for slot in (json::class-slots class1)
for slot-name = (json::slot-definition-name slot)
always (if (slot-boundp object1 slot-name)
(and (slot-boundp object2 slot-name)
(equal-objects-p
(slot-value object1 slot-name)
(slot-value object2 slot-name)))
(not (slot-boundp object2 slot-name))))))))
(test json-object
(let ((input " { \"hello\" : \"hej\" ,
\"hi\" : \"tjena\"
}"))
(let ((*json-symbols-package* (find-package :keyword)))
(with-decoder-simple-list-semantics
(is (equalp '((:hello . "hej") (:hi . "tjena"))
(decode-json-from-string input)))
(is-false (decode-json-from-string " { } "))
(is-false (decode-json-from-string "{}"))))
#+cl-json-clos
(let ((*json-symbols-package* (find-package :json-test)))
(with-decoder-simple-clos-semantics
(is (equal-objects-p
(json:make-object '((hello . "hej") (hi . "tjena")) nil)
(decode-json-from-string input)))
(is-false (#-cmu identity #+cmu symbol-package
(class-name (class-of (decode-json-from-string input)))))
(is (equal-objects-p
(decode-json-from-string "{ }")
(json:make-object nil nil)))))))
(defclass foo () ((bar :initarg :bar) (baz :initarg :baz)))
(defclass goo () ((quux :initarg :quux :initform 933)))
(defclass frob (foo goo) ())
(defclass p-frob (frob) ((prototype :reader prototype)))
#+cl-json-clos
(test json-object-with-prototype
(let ((*json-symbols-package* (find-package :keyword))
(*prototype-name* 'prototype)
(input "{\"bar\": 46,
\"xyzzy\": true,
\"quux\": 98,
\"prototype\": ~A}"))
(with-decoder-simple-list-semantics
(is (equalp
(decode-json-from-string
(format nil input "{\"lispPackage\":\"jsonTest\",
\"lispClass\":\"frob\"}"))
'((:bar . 46) (:xyzzy . t) (:quux . 98)
(:prototype . ((:lisp-package . "jsonTest")
(:lisp-class . "frob")))))))
(with-decoder-simple-clos-semantics
(is (equal-objects-p
(make-instance 'frob :bar 46 :quux 98)
(decode-json-from-string
(format nil input "{\"lispPackage\":\"jsonTest\",
\"lispClass\":\"frob\"}"))))
(finalize-inheritance (find-class 'foo))
(finalize-inheritance (find-class 'goo))
(is (equal-objects-p
(json:make-object '((bar . 46) (xyzzy . t) (quux . 98))
nil '(foo goo))
(decode-json-from-string
(format nil input "{\"lispSuperclasses\": [\"foo\", \"goo\"],
\"lispPackage\":\"jsonTest\"}"))))
(is (typep
(prototype (decode-json-from-string
(format nil input "{\"lispPackage\":\"jsonTest\",
\"lispClass\":\"pFrob\"}")))
'prototype))
(is (equalp
'((bar . 46) (xyzzy . t) (quux . 98))
(decode-json-from-string
(format nil input "{\"lispClass\": \"cons\",
\"lispPackage\":\"jsonTest\"}"))))
(is (loop with ht = (decode-json-from-string
(format nil input "{\"lispClass\": \"hashTable\",
\"lispPackage\":\"jsonTest\"}"))
initially (if (/= (hash-table-count ht) 3) (return nil))
for k being each hash-key of ht
using (hash-value v)
always (case k
(bar (eql v 46))
(xyzzy (eql v t))
(quux (eql v 98))
(t nil)))))))
(test json-object-factory
(let (*ht* *key* obj
(*json-symbols-package* 'json-test))
(declare (special *ht* *key*))
(json:bind-custom-vars
(:beginning-of-object #'(lambda () (setq *ht* (make-hash-table)))
:object-key #'(lambda (key)
(setq *key* (json-intern (camel-case-to-lisp key))))
:object-value #'(lambda (value) (setf (gethash *key* *ht*) value))
:end-of-object #'(lambda () *ht*)
:object-scope '(*ht* *key*))
(setf obj (decode-json-from-string " { \"hello\" : \"hej\" ,
\"hi\" : \"tjena\"
}"))
(is (string= "hej" (gethash 'hello obj)))
(is (string= "tjena" (gethash 'hi obj))))))
(test set-list-decoder-semantics
(with-shadowed-custom-vars
(let ((tricky-json "{\"start_XPos\":98,\"start_YPos\":4}")
(*json-symbols-package* (find-package :keyword)))
(set-decoder-simple-list-semantics)
(is (equal '((:START--*X-POS . 98) (:START--*Y-POS . 4))
(decode-json-from-string tricky-json))))))
(test custom-identifier-name-to-key
"Interns of many unique symbols could potentially use a lot of memory.
An attack could exploit this by submitting something that is passed
through cl-json that has many very large, unique symbols. See the
safe-symbols-parsing function here for a cure."
(with-decoder-simple-list-semantics
(flet ((safe-symbols-parsing (name)
(or (find-symbol name *json-symbols-package*)
(error "unknown symbols not allowed"))))
(let ((good-symbols "{\"car\":1,\"cdr\":2}")
(bad-symbols "{\"could-be\":1,\"a-denial-of-service-attack\":2}")
(*json-symbols-package* (find-package :cl))
(*identifier-name-to-key* #'safe-symbols-parsing))
(is (equal '((car . 1) (cdr . 2))
(decode-json-from-string good-symbols)))
(signals error (decode-json-from-string bad-symbols))))))
(test safe-json-intern
(with-decoder-simple-list-semantics
(let ((good-symbols "{\"car\":1,\"cdr\":2}")
(bad-symbols "{\"could-be\":1,\"a-denial-of-service-attack\":2}")
(*json-symbols-package* (find-package :cl))
(*identifier-name-to-key* #'safe-json-intern))
(is (equal '((car . 1) (cdr . 2))
(decode-json-from-string good-symbols)))
(signals unknown-symbol-error (decode-json-from-string bad-symbols)))))
(test json-object-camel-case
(with-decoder-simple-list-semantics
(let ((*json-symbols-package* (find-package :keyword)))
(is (equalp '((:hello-key . "hej")
(:*hi-starts-with-upper-case . "tjena")
(:+json+-all-capitals . "totae majusculae")
(:+two-words+ . "duo verba")
(:camel-case--*mixed--+4-parts+ . "partes miscella quatuor"))
(decode-json-from-string " { \"helloKey\" : \"hej\" ,
\"HiStartsWithUpperCase\" : \"tjena\",
\"JSONAllCapitals\": \"totae majusculae\",
\"TWO_WORDS\": \"duo verba\",
\"camelCase_Mixed_4_PARTS\": \"partes miscella quatuor\"
}"))))))
(test json-object-simplified-camel-case
;; Compare this with json-object-camel-case above
(with-decoder-simple-list-semantics
(let ((*json-symbols-package* (find-package :keyword))
(*json-identifier-name-to-lisp* #'simplified-camel-case-to-lisp))
(is (equalp '((:hello-key . "hej")
(:hi-starts-with-upper-case . "tjena")
(:jsonall-capitals . "totae majusculae")
(:two_words . "duo verba")
(:camel-case_mixed_4_parts . "partes miscella quatuor"))
(decode-json-from-string " { \"helloKey\" : \"hej\" ,
\"HiStartsWithUpperCase\" : \"tjena\",
\"JSONAllCapitals\": \"totae majusculae\",
\"TWO_WORDS\": \"duo verba\",
\"camelCase_Mixed_4_PARTS\": \"partes miscella quatuor\"
}"))))))
(defmacro with-fp-overflow-handler (handler-expr &body body)
(let ((err (gensym)))
`(handler-bind ((floating-point-overflow
(lambda (,err)
(declare (ignore ,err))
,handler-expr)))
,@body)))
(defmacro with-no-char-handler (handler-expr &body body)
(let ((err (gensym)))
`(handler-bind ((no-char-for-code
(lambda (,err)
(declare (ignore ,err))
,handler-expr)))
,@body)))
(test json-number
(is (= 100 (decode-json-from-string "100")))
(is (= 10.01 (decode-json-from-string "10.01")))
(is (= -2.3 (decode-json-from-string "-2.3")))
(is (= -2.3e3 (decode-json-from-string "-2.3e3")))
(is (= -3e4 (decode-json-from-string "-3e4")))
(is (= 3e4 (decode-json-from-string "3e4")))
(let ((*read-default-float-format* 'double-float))
(is (= 2d40 (decode-json-from-string "2e40"))))
#-(or (and sbcl darwin) (and allegro macosx))
(is (equalp "BIG:2e444"
(with-fp-overflow-handler
(invoke-restart 'bignumber-string "BIG:")
(decode-json-from-string "2e444"))))
#-(or (and sbcl darwin) (and allegro macosx))
(is (= (* 2 (expt 10 444))
(with-fp-overflow-handler
(invoke-restart 'rational-approximation)
(decode-json-from-string "2e444"))))
;; In SBCL on Darwin, constructing the float from parts by explicit
;; operations yields #.SB-EXT:SINGLE-FLOAT-POSITIVE-INFINITY.
#+(and sbcl darwin)
(is (= (* 2.0 (expt 10.0 444))
(decode-json-from-string "2e444"))))
(defparameter *json-test-files-path*
(asdf:system-relative-pathname "cl-json/test" "t/"))
(defun test-file (name)
(make-pathname :name name :type "json" :defaults *json-test-files-path*))
(defun decode-file (path)
(with-open-file (stream path :direction :input)
(with-fp-overflow-handler (invoke-restart 'placeholder :infty)
(with-no-char-handler (invoke-restart 'substitute-char #\?)
(decode-json-strict stream)))))
;; All test files are taken from http://www.crockford.com/JSON/JSON_checker/test/
(test pass-1
(decode-file (test-file "pass1")))
(test pass-2
(decode-file (test-file "pass2")))
(test pass-3
(decode-file (test-file "pass3")))
(defparameter *ignore-tests* '(
1 ; says: "A JSON payload should be an object or array, not a string.", but who cares?
7 ; says: ["Comma after the close"], ,but decode-file stops parsing after one object has been retrieved
8 ; says ["Extra close"]] ,but decode-file stops parsing after one object has been retrieved
10; says {"Extra value after close": true} "misplaced quoted value", but
; decode-file stops parsing after one object has been retrieved
18; says [[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]], but there is no formal limit
))
(defparameter *ignore-tests-strict* '(
18; says [[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]], but there is no formal limit
))
(test fail-files
(dotimes (x 24)
(if (member x *ignore-tests-strict*)
(is-true t)
(5am:signals error
(decode-file (test-file (format nil "fail~a" x)))))))
(defun contents-of-file(file)
(with-open-file (stream file :direction :input)
(let ((s (make-string (file-length stream))))
(read-sequence s stream)
s)))
(test decoder-performance
(let* ((json-string (contents-of-file (test-file "pass1")))
(chars (length json-string))
(count 1000))
(format t "Decoding ~a varying chars from memory ~a times." chars count)
(time
(dotimes (x count)
(let ((discard-soon
(with-fp-overflow-handler (invoke-restart 'placeholder :infty)
(with-no-char-handler (invoke-restart 'substitute-char #\?)
(decode-json-from-string json-string)))))
(funcall #'identity discard-soon))))));Do something so the compiler don't optimize too much
(test decoder-performance-with-simplified-camel-case
(let* ((json-string (contents-of-file (test-file "pass1")))
(chars (length json-string))
(count 1000))
(format t "Decoding ~a varying chars from memory ~a times." chars count)
(time
(with-shadowed-custom-vars
(let ((*json-identifier-name-to-lisp* #'simplified-camel-case-to-lisp))
(dotimes (x count)
(let ((discard-soon
(with-fp-overflow-handler (invoke-restart 'placeholder :infty)
(with-no-char-handler (invoke-restart 'substitute-char #\?)
(decode-json-from-string json-string)))))
(funcall #'identity discard-soon)))))))) ;Do something so the compiler don't optimize too much
;;#+when-u-want-profiling
;;(defun profile-decoder-performance()
;; #+sbcl
;; (progn
;; (let ((json-string (contents-of-file (test-file "pass1")))
;; (count 10))
;; (format t "Parsing test-file pass1 from memory ~a times." count)
;; (sb-sprof:with-profiling ()
;; (dotimes (x count)
;; (let ((discard-soon (decode-json-from-string json-string)))
;; (funcall #'identity discard-soon))))
;; (sb-sprof:report)
;; nil)))
(test non-strict-json
(let ((not-strictly-valid "\"right\\'s of man\""))
(5am:signals json:json-syntax-error
(json:decode-json-from-string not-strictly-valid))
(let ((*use-strict-json-rules* nil))
(declare (special *use-strict-json-rules*))
(is (string= (json:decode-json-from-string not-strictly-valid)
"right's of man")))))
#+cl-json-clos
(defun first-bound-slot-name (x)
(loop for slot in (json::class-slots (class-of x))
for slot-name = (json::slot-definition-name slot)
if (slot-boundp x slot-name)
return slot-name))
(test test*json-symbols-package*
(let ((*json-symbols-package* nil)
(*package* (find-package :json-test))
x)
(with-decoder-simple-list-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (caar x))
(find-package :json-test))))
#+cl-json-clos
(with-decoder-simple-clos-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (first-bound-slot-name x))
(find-package :json-test)))))
(let ((*json-symbols-package* (find-package :cl-user))
x)
(with-decoder-simple-list-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (caar x))
(find-package :cl-user))))
#+cl-json-clos
(with-decoder-simple-clos-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (first-bound-slot-name x))
(find-package :cl-user)))))
(when (eq *json-symbols-package* (find-package :keyword))
(let (x)
(with-decoder-simple-list-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (caar x))
(find-package :keyword))))
#+(and cl-json-clos
(not allegro) ; seems like allegro doesn't, either.
(not cmu)) ; CMUCL does not allow keywords as slot names
(with-decoder-simple-clos-semantics
(setf x (decode-json-from-string "{\"x\":1}"))
(is (equal (symbol-package (first-bound-slot-name x))
(find-package :keyword)))))))
| 17,549 | Common Lisp | .lisp | 374 | 37.398396 | 109 | 0.566151 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 1b40b55cad982632157fddb0f4e04d18b555de860b49ce40830f04dca0e811ae | 43,034 | [
9955
] |
43,035 | testmisc.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/t/testmisc.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base:10; Package: JSON-TEST -*-
(in-package :json-test)
(in-suite json)
(test test-json-bind
(json-bind (hello hi ciao) "{\"hello\":100,\"hi\":5}"
(is (= hello 100))
(is (= hi 5))
(is-false ciao)))
(test test-json-bind-advanced
(json-bind (hello-world
sub-obj.property
sub-obj.missing-property
sub-obj.even-deeper-obj.some-stuff)
"{\"helloWorld\":100,\"subObj\":{\"property\":20,\"evenDeeperObj\":{\"someStuff\":\"Guten Tag\"}}}"
(is (= hello-world 100))
(is (= sub-obj.property 20))
(is-false sub-obj.missing-property)
(is (string= sub-obj.even-deeper-obj.some-stuff "Guten Tag"))))
(test json-bind-in-bind-bug
;; A problem with json-bind. TODO: Fix it, but leave this testcase
(let* ((input-json-rpc "{\"method\":\"rc\",\"id\":\"1\",\"params\":
[\"0\",{\"id\":\"pingId\",\"name\":\"ping\"},[],
[{\"name\":\"tableTennisGroupName\",\"id\":\"tableTennisGroupId\"}]]}")
(input1 (copy-seq input-json-rpc))
(input2 (copy-seq input-json-rpc))
result1 result2 temp)
(flet ((invoke-json-rpc (struct)
(json:json-bind (method id params)
struct
(format nil "{\"result\":\"~a\",\"error\":null,\"id\":\"1\"}"
params))))
;; This does not work correctly
(json:json-bind (result error id)
(invoke-json-rpc input1)
(setf result1 result))
;; But this works
(setf temp (invoke-json-rpc input2))
(json:json-bind (result error id)
temp
(setf result2 result))
;; and to prove it:
(is (string= input1 input2)) ;; We have same input
(is (string= result1 result2))))) ;; so we should get same output
;;; Invalidated by the patch ``Re-implemented JSON-BIND (to illustrate
;;; dynamic customization).'' (Wed Jan 21 20:49:22 MSK 2009)
;
; (test test-json-bind-with-alist
; (with-decoder-simple-list-semantics
; (let ((the-alist (decode-json-from-string "{\"hello\":100,\"hi\":5}")))
; (json-bind (hello hi ciao) the-alist
; (is (= hello 100))
; (is (= hi 5))
; (is-false ciao)))))
;
; (test assoc-lookup
; (is (equalp '(json::cdas widget-id (json::cdas parent data))
; (macroexpand-1 '(json::assoc-lookup parent widget-id data)))))
;; JSON-RPC
;; Old syntax:
;; (defun-json-rpc foo (x y)
;; "Adds two numbers"
;; (+ x y))
(defun-json-rpc foo-g :guessing (x y)
"Adds two numbers, returns number and string"
(let ((val (+ x y)))
`((:digits . ,val)
(:letters . ,(format nil "~R" val)))))
(defun-json-rpc foo-e :explicit (x y)
"Adds two numbers, returns number and string"
(let ((val (+ x y)))
`(:object :digits ,val
:letters ,(format nil "~R" val))))
(defun-json-rpc foo-s :streaming (x y)
"Adds two numbers, returns number and string"
(let ((val (+ x y)))
(format nil "{\"digits\":~a,\"letters\":\"~R\"}" val val)))
(defun-json-rpc foo-b :boolean (x)
"Takes a lisp value and just passes it through identity;
we can use this to probe the behavior of the boolean
encoding."
(if (equalp x "error")
(error "Intentionally raised error.")
x))
(defun-json-rpc foo-a :array (x)
"Takes a lisp value and just passes it through identity;
we can use this to probe the behavior of the array
encoding."
(if (equalp x "error")
(error "Intentionally raised error.")
x))
(defun json-rpc-2-p (&optional (flag json-rpc:*json-rpc-version*))
(eql (aref flag 0) #\2))
(defun test-json-rpc-helper (method-name)
(with-decoder-simple-list-semantics
(let (result)
(setf result (json-rpc:invoke-rpc
(format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"method\":\"~a\",\"params\":[1,2],\"id\":999}" (json-rpc-2-p) method-name)))
(is (string= result
(format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"result\":{\"digits\":3,\"letters\":\"three\"},~@[~*\"error\":null,~]\"id\":999}"
(json-rpc-2-p) (not (json-rpc-2-p))))))))
(defun test-json-rpc-boolean-helper (input-value output-value)
(with-decoder-simple-list-semantics
(let* ((error (eq output-value :error))
(expected (cond ((eq output-value :error)
nil)
(output-value "true")
(t "false")))
(input-encoded
(with-guessing-encoder
(encode-json-to-string input-value)))
(result
(handler-bind
((json-rpc-call-error #'(lambda (x)
(declare (ignore x))
(invoke-restart 'json-rpc:send-internal-error))))
(json-rpc:invoke-rpc
(format nil
"{~@[~*\"jsonrpc\":\"2.0\",~]\"method\":\"fooB\",\"params\":[~a],\"id\":999}"
(json-rpc-2-p) input-encoded)))))
(if error
(let ((res (decode-json-from-string result)))
(if (json-rpc-2-p)
;; if there's an error in 2.0, the result must be missing, not null
(is (and (null (assoc :result res))
(cdr (assoc :error res))))
(is (and (null (cdr (assoc :result res)))
(cdr (assoc :error res))))))
(is (string= result
(format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"result\":~a,~@[~*\"error\":null,~]\"id\":999}"
(json-rpc-2-p) expected
(not (json-rpc-2-p)))))))))
(defun test-json-rpc-array-helper (input-value output-value)
(with-decoder-simple-list-semantics
(let* ((error (eq output-value :error))
(expected (cond ((eq output-value :error)
nil)
(t
(with-guessing-encoder
(encode-json-to-string output-value)))))
(input-encoded
(with-guessing-encoder
(encode-json-to-string input-value)))
(result
(handler-bind
((error #'(lambda (x)
(invoke-restart 'json-rpc:send-error
(format nil "~a" x)
999))))
(json-rpc:invoke-rpc
(format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"method\":\"fooA\",\"params\":[~a],\"id\":999}"
(json-rpc-2-p) input-encoded)))))
(if error
(let ((res (decode-json-from-string result)))
(is (and (null (cdr (assoc :result res)))
(cdr (assoc :error res)))))
(is (string= result
(format nil "{~@[~*\"jsonrpc\":\"2.0\",~]\"result\":~a,~@[~*\"error\":null,~]\"id\":999}"
(json-rpc-2-p) expected
(not (json-rpc-2-p)))))))))
(defmacro test-json-rpc-both (name &rest body)
(let ((two-oh-name
(intern (concatenate 'string (symbol-name name) "-"
(symbol-name '#:json-rpc-2.0)))))
`(progn
(test ,name
,@body)
(test ,two-oh-name
(let ((json-rpc:*json-rpc-version* json-rpc:+json-rpc-2.0+))
,@body)))))
(test-json-rpc-both test-json-rpc
(test-json-rpc-helper "fooG"))
(test-json-rpc-both test-json-rpc-explicit
(test-json-rpc-helper "fooE"))
(test-json-rpc-both test-json-rpc-streaming
(test-json-rpc-helper "fooS"))
(test-json-rpc-both test-json-rpc-boolean-true
(test-json-rpc-boolean-helper t t))
(test-json-rpc-both test-json-rpc-boolean-false
(test-json-rpc-boolean-helper nil nil))
(test-json-rpc-both test-json-rpc-boolean-error
(test-json-rpc-boolean-helper :error :error))
(test-json-rpc-both test-json-rpc-array-simple
(test-json-rpc-array-helper (list 1 2 3) (list 1 2 3)))
(test-json-rpc-both test-json-rpc-array-array
(test-json-rpc-array-helper #(1 2 3) (list 1 2 3)))
(test-json-rpc-both test-json-rpc-empty-array
(test-json-rpc-array-helper #() #()))
(test-json-rpc-both test-json-rpc-array-nil
(test-json-rpc-array-helper nil #()))
(test-json-rpc-both test-json-rpc-array-scalar-error
(test-json-rpc-array-helper 1 :error))
(test test-json-rpc-unknown-fn
(with-decoder-simple-list-semantics
(let ((*json-symbols-package* (find-package :json-test))
result)
(setf result (json-rpc:invoke-rpc "{\"method\":\"secretmethod\",\"params\":[1,2],\"id\":\"my id\"}"))
(json-bind (result error id) result
(is-false result)
(is-true error)
(is (string= id "my id"))))))
| 8,823 | Common Lisp | .lisp | 200 | 34.435 | 143 | 0.538121 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 39f86e3cbfa982d5f2ac2f23e5af29514f19ddb69166d35aaf7cdd3f0711c211 | 43,035 | [
286616
] |
43,036 | src.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/puri-20201016-git/src.lisp | ;; -*- mode: common-lisp; package: puri -*-
;; Support for URIs
;; For general URI information see RFC2396.
;;
;; copyright (c) 1999-2002 Franz Inc, Berkeley, CA - All rights reserved.
;; copyright (c) 2002-2005 Franz Inc, Oakland, CA - All rights reserved.
;; copyright (c) 2003-2010 Kevin Rosenberg
;;
;; This code is free software; you can redistribute it and/or
;; modify it under the terms of the version 2.1 of
;; the GNU Lesser General Public License as published by
;; the Free Software Foundation, as clarified by the
;; preamble found here:
;; http://opensource.franz.com/preamble.html
;;
;; Versions ported from Franz's opensource release
;; uri.cl,v 2.3.6.4.2.1 2001/08/09 17:42:39 layer
;; uri.cl,v 2.9.84.1 2005/08/11 18:38:52 layer
;; This code is distributed in the hope that it will be useful,
;; but without any warranty; without even the implied warranty of
;; merchantability or fitness for a particular purpose. See the GNU
;; Lesser General Public License for more details.
(defpackage #:puri
(:use #:cl)
#-(or allegro zacl) (:nicknames #:net.uri)
(:export
#:uri ; the type and a function
#:uri-p
#:copy-uri
#:uri-scheme ; and slots
#:uri-host #:uri-port
#:uri-path
#:uri-query
#:uri-is-ip6
#:uri-fragment
#:uri-plist
#:uri-authority ; pseudo-slot accessor
#:urn ; class
#:urn-nid ; pseudo-slot accessor
#:urn-nss ; pseudo-slot accessor
#:*strict-parse*
#:parse-uri
#:merge-uris
#:enough-uri
#:uri-parsed-path
#:render-uri
#:make-uri-space ; interning...
#:uri-space
#:uri=
#:intern-uri
#:unintern-uri
#:do-all-uris
#:uri-parse-error ;; Added by KMR
))
(in-package #:puri)
(eval-when (:compile-toplevel) (declaim (optimize (speed 3))))
#-allegro
(defun parse-body (forms &optional env)
"Parses a body, returns (VALUES docstring declarations forms)"
(declare (ignore env))
;; fixme -- need to add parsing of multiple declarations
(let (docstring declarations)
(when (stringp (car forms))
(setq docstring (car forms))
(setq forms (cdr forms)))
(when (and (listp (car forms))
(symbolp (caar forms))
(string-equal (symbol-name '#:declare)
(symbol-name (caar forms))))
(setq declarations (car forms))
(setq forms (cdr forms)))
(values docstring declarations forms)))
(defun shrink-vector (str size)
#+allegro
(excl::.primcall 'sys::shrink-svector str size)
#+sbcl
(setq str (sb-kernel:shrink-vector str size))
#+cmu
(lisp::shrink-vector str size)
#+lispworks
(system::shrink-vector$vector str size)
#+scl
(common-lisp::shrink-vector str size)
#-(or allegro cmu lispworks sbcl scl)
(setq str (subseq str 0 size))
str)
;; KMR: Added new condition to handle cross-implementation variances
;; in the parse-error condition many implementations define
(define-condition uri-parse-error (parse-error)
((fmt-control :initarg :fmt-control :accessor fmt-control)
(fmt-arguments :initarg :fmt-arguments :accessor fmt-arguments ))
(:report (lambda (c stream)
(format stream "Parse error:")
(apply #'format stream (fmt-control c) (fmt-arguments c)))))
(defun .parse-error (fmt &rest args)
(error 'uri-parse-error :fmt-control fmt :fmt-arguments args))
#-allegro
(defun internal-reader-error (stream fmt &rest args)
(apply #'format stream fmt args))
#-allegro (defvar *current-case-mode* :case-insensitive-upper)
#+allegro (eval-when (:compile-toplevel :load-toplevel :execute)
(import '(excl:*current-case-mode*
excl:delimited-string-to-list
excl::parse-body
excl::internal-reader-error
excl:if*)))
#-allegro
(defmethod position-char (char (string string) start max)
(declare (optimize (speed 3) (safety 0) (space 0))
(fixnum start max) (string string))
(do* ((i start (1+ i)))
((= i max) nil)
(declare (fixnum i))
(when (char= char (char string i)) (return i))))
#-allegro
(defun delimited-string-to-list (string &optional (separator #\space)
skip-terminal)
(declare (optimize (speed 3) (safety 0) (space 0)
(compilation-speed 0))
(type string string)
(type character separator))
(do* ((len (length string))
(output '())
(pos 0)
(end (position-char separator string pos len)
(position-char separator string pos len)))
((null end)
(if (< pos len)
(push (subseq string pos) output)
(when (and (plusp len) (not skip-terminal))
(push "" output)))
(nreverse output))
(declare (type fixnum pos len)
(type (or null fixnum) end))
(push (subseq string pos end) output)
(setq pos (1+ end))))
#-allegro
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar if*-keyword-list '("then" "thenret" "else" "elseif"))
(defmacro if* (&rest args)
(do ((xx (reverse args) (cdr xx))
(state :init)
(elseseen nil)
(totalcol nil)
(lookat nil nil)
(col nil))
((null xx)
(cond ((eq state :compl)
`(cond ,@totalcol))
(t (error "if*: illegal form ~s" args))))
(cond ((and (symbolp (car xx))
(member (symbol-name (car xx))
if*-keyword-list
:test #'string-equal))
(setq lookat (symbol-name (car xx)))))
(cond ((eq state :init)
(cond (lookat (cond ((string-equal lookat "thenret")
(setq col nil
state :then))
(t (error
"if*: bad keyword ~a" lookat))))
(t (setq state :col
col nil)
(push (car xx) col))))
((eq state :col)
(cond (lookat
(cond ((string-equal lookat "else")
(cond (elseseen
(error
"if*: multiples elses")))
(setq elseseen t)
(setq state :init)
(push `(t ,@col) totalcol))
((string-equal lookat "then")
(setq state :then))
(t (error "if*: bad keyword ~s"
lookat))))
(t (push (car xx) col))))
((eq state :then)
(cond (lookat
(error
"if*: keyword ~s at the wrong place " (car xx)))
(t (setq state :compl)
(push `(,(car xx) ,@col) totalcol))))
((eq state :compl)
(cond ((not (string-equal lookat "elseif"))
(error "if*: missing elseif clause ")))
(setq state :init))))))
(defclass uri ()
(
;;;; external:
(scheme :initarg :scheme :initform nil :accessor uri-scheme)
(host :initarg :host :initform nil :accessor uri-host)
(port :initarg :port :initform nil :accessor uri-port)
(path :initarg :path :initform nil :accessor uri-path)
(query :initarg :query :initform nil :accessor uri-query)
(fragment :initarg :fragment :initform nil :accessor uri-fragment)
(plist :initarg :plist :initform nil :accessor uri-plist)
;;;; internal:
(escaped
;; used to prevent unnessary work, looking for chars to escape and
;; unescape.
:initarg :escaped :initform nil :accessor uri-escaped)
(string
;; the cached printable representation of the URI. It *might* be
;; different than the original string, though, because the user might
;; have escaped non-reserved chars--they won't be escaped when the URI
;; is printed.
:initarg :string :initform nil :accessor uri-string)
(parsed-path
;; the cached parsed representation of the URI path.
:initarg :parsed-path
:initform nil
:accessor .uri-parsed-path)
(is-ip6
:initarg :is-ip6
:initform nil
:accessor uri-is-ip6)
(hashcode
;; cached sxhash, so we don't have to compute it more than once.
:initarg :hashcode :initform nil :accessor uri-hashcode)))
(defclass urn (uri)
((nid :initarg :nid :initform nil :accessor urn-nid)
(nss :initarg :nss :initform nil :accessor urn-nss)))
(eval-when (:compile-toplevel :execute)
(defmacro clear-caching-on-slot-change (name)
`(defmethod (setf ,name) :around (new-value (self uri))
(declare (ignore new-value))
(prog1 (call-next-method)
(setf (uri-string self) nil)
,@(when (eq name 'uri-path) `((setf (.uri-parsed-path self) nil)))
(setf (uri-hashcode self) nil))))
)
(clear-caching-on-slot-change uri-scheme)
(clear-caching-on-slot-change uri-host)
(clear-caching-on-slot-change uri-port)
(clear-caching-on-slot-change uri-path)
(clear-caching-on-slot-change uri-query)
(clear-caching-on-slot-change uri-fragment)
(defmethod make-load-form ((self uri) &optional env)
(declare (ignore env))
`(make-instance ',(class-name (class-of self))
:scheme ,(uri-scheme self)
:host ,(uri-host self)
:port ,(uri-port self)
:path ',(uri-path self)
:query ,(uri-query self)
:fragment ,(uri-fragment self)
:plist ',(uri-plist self)
:string ,(uri-string self)
:parsed-path ',(.uri-parsed-path self)))
(defmethod uri-p ((thing uri)) t)
(defmethod uri-p ((thing t)) nil)
(defun copy-uri (uri
&key place
(scheme (when uri (uri-scheme uri)))
(host (when uri (uri-host uri)))
(port (when uri (uri-port uri)))
(path (when uri (uri-path uri)))
(parsed-path
(when uri (copy-list (.uri-parsed-path uri))))
(query (when uri (uri-query uri)))
(fragment (when uri (uri-fragment uri)))
(plist (when uri (copy-list (uri-plist uri))))
(class (when uri (class-of uri)))
&aux (escaped (when uri (uri-escaped uri))))
(if* place
then (setf (uri-scheme place) scheme)
(setf (uri-host place) host)
(setf (uri-port place) port)
(setf (uri-path place) path)
(setf (.uri-parsed-path place) parsed-path)
(setf (uri-query place) query)
(setf (uri-fragment place) fragment)
(setf (uri-plist place) plist)
(setf (uri-escaped place) escaped)
(setf (uri-string place) nil)
(setf (uri-hashcode place) nil)
place
elseif (eq 'uri class)
then ;; allow the compiler to optimize the call to make-instance:
(make-instance 'uri
:scheme scheme :host host :port port :path path
:parsed-path parsed-path
:query query :fragment fragment :plist plist
:escaped escaped :string nil :hashcode nil)
else (make-instance class
:scheme scheme :host host :port port :path path
:parsed-path parsed-path
:query query :fragment fragment :plist plist
:escaped escaped :string nil :hashcode nil)))
(defmethod uri-parsed-path ((uri uri))
(when (uri-path uri)
(when (null (.uri-parsed-path uri))
(setf (.uri-parsed-path uri)
(parse-path (uri-path uri) (uri-escaped uri))))
(.uri-parsed-path uri)))
(defmethod (setf uri-parsed-path) (path-list (uri uri))
(assert (and (consp path-list)
(or (member (car path-list) '(:absolute :relative)
:test #'eq))))
(setf (uri-path uri) (render-parsed-path path-list t))
(setf (.uri-parsed-path uri) path-list)
path-list)
(defun uri-authority (uri)
(when (uri-host uri)
(let ((*print-pretty* nil))
(format nil "~a~@[:~a~]" (uri-host uri) (uri-port uri)))))
(defun uri-nid (uri)
(if* (equalp "urn" (uri-scheme uri))
then (uri-host uri)
else (error "URI is not a URN: ~s." uri)))
(defun uri-nss (uri)
(if* (equalp "urn" (uri-scheme uri))
then (uri-path uri)
else (error "URI is not a URN: ~s." uri)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Parsing
(defparameter *excluded-characters*
(append
;; exclude control characters
(loop for i from 0 to #x1f
collect (code-char i))
'(;; `delims' (except #\%, because it's handled specially):
#\< #\> #\" #\space #\#
#\Rubout ;; (code-char #x7f)
;; `unwise':
#\{ #\} #\| #\\ #\^ #\[ #\] #\`))
"Excluded charcters from RFC2396 (http://www.ietf.org/rfc/rfc2396.txt 2.4.3)")
(defun reserved-char-vector (chars &key except)
(do* ((a (make-array 128 :element-type 'bit :initial-element 0))
(chars chars (cdr chars))
(c (car chars) (car chars)))
((null chars) a)
(if* (and except (member c except :test #'char=))
thenret
else (setf (sbit a (char-int c)) 1))))
(defparameter *reserved-characters*
(reserved-char-vector
(append *excluded-characters*
'(#\; #\/ #\? #\: #\@ #\& #\= #\+ #\$ #\, #\%))))
(defparameter *reserved-authority-characters*
(reserved-char-vector
(append *excluded-characters* '(#\; #\/ #\? #\: #\@))))
(defparameter *reserved-path-characters*
(reserved-char-vector
(append *excluded-characters*
'(#\; #\%
;;;;The rfc says this should be here, but it doesn't make sense.
;; #\=
#\/ #\?))))
(defparameter *reserved-fragment-characters*
(reserved-char-vector (remove #\# *excluded-characters*)))
(eval-when (:compile-toplevel :execute)
(defun gen-char-range-list (start end)
(do* ((res '())
(endcode (1+ (char-int end)))
(chcode (char-int start)
(1+ chcode))
(hyphen nil))
((= chcode endcode)
;; - has to be first, otherwise it signifies a range!
(if* hyphen
then (setq res (nreverse res))
(push #\- res)
res
else (nreverse res)))
(if* (= #.(char-int #\-) chcode)
then (setq hyphen t)
else (push (code-char chcode) res))))
)
(defparameter *valid-nid-characters*
(reserved-char-vector
'#.(nconc (gen-char-range-list #\a #\z)
(gen-char-range-list #\A #\Z)
(gen-char-range-list #\0 #\9)
'(#\- #\. #\+))))
(defparameter *reserved-nss-characters*
(reserved-char-vector
(append *excluded-characters* '(#\& #\~ #\/ #\?))))
(defparameter *illegal-characters*
(reserved-char-vector (set-difference *excluded-characters*
'(#\# #\[ #\]))))
(defparameter *strict-illegal-query-characters*
(reserved-char-vector (append '(#\?) (remove #\# *excluded-characters*))))
(defparameter *illegal-query-characters*
(reserved-char-vector
*excluded-characters* :except '(#\^ #\| #\#)))
(defparameter *valid-ip6-characters*
(reserved-char-vector
'#.(nconc (gen-char-range-list #\a #\f)
(gen-char-range-list #\A #\F)
(gen-char-range-list #\0 #\9)
'(#\: #\]))))
(defun parse-uri (thing &key (class 'uri) &aux escape)
(when (uri-p thing) (return-from parse-uri thing))
(setq escape (escape-p thing))
(multiple-value-bind (scheme host port path query fragment is-ip6)
(parse-uri-string thing)
(when scheme
(setq scheme
(intern (funcall
(case *current-case-mode*
((:case-insensitive-upper :case-sensitive-upper)
#'string-upcase)
((:case-insensitive-lower :case-sensitive-lower)
#'string-downcase))
(decode-escaped-encoding scheme escape))
(find-package :keyword))))
(when (and scheme (eq :urn scheme))
(return-from parse-uri
(make-instance 'urn :scheme scheme :nid host :nss path)))
(when host (setq host (decode-escaped-encoding host escape)))
(when port
(setq port (read-from-string port))
(when (not (numberp port)) (error "port is not a number: ~s." port))
(when (not (plusp port))
(error "port is not a positive integer: ~d." port))
(when (eql port (case scheme
(:http 80)
(:https 443)
(:ftp 21)
(:telnet 23)))
(setq port nil)))
(when (or (string= "" path)
(and ;; we canonicalize away a reference to just /:
scheme
(member scheme '(:http :https :ftp) :test #'eq)
(string= "/" path)))
(setq path nil))
(when path
(setq path
(decode-escaped-encoding path escape *reserved-path-characters*)))
(when query (setq query (decode-escaped-encoding query escape)))
(when fragment
(setq fragment
(decode-escaped-encoding fragment escape
*reserved-fragment-characters*)))
(if* (eq 'uri class)
then ;; allow the compiler to optimize the make-instance call:
(make-instance 'uri
:scheme scheme
:host host
:is-ip6 is-ip6
:port port
:path path
:query query
:fragment fragment
:escaped escape)
else ;; do it the slow way:
(make-instance class
:scheme scheme
:host host
:is-ip6 is-ip6
:port port
:path path
:query query
:fragment fragment
:escaped escape))))
(defmethod uri ((thing uri))
thing)
(defmethod uri ((thing string))
(parse-uri thing))
(defmethod uri ((thing t))
(error "Cannot coerce ~s to a uri." thing))
(defvar *strict-parse* t)
(defun parse-uri-string (string &aux (illegal-chars *illegal-characters*))
(declare (optimize (speed 3)))
;; Speed is important, so use a specialized state machine instead of
;; regular expressions for parsing the URI string. The regexp we are
;; simulating:
;; ^(([^:/?#]+):)?
;; (//([^/?#]*))?
;; May include a []-pair for ipv6
;; ([^?#]*)
;; (\?([^#]*))?
;; (#(.*))?
(let* ((state 0)
(start 0)
(end (length string))
(tokval nil)
(scheme nil)
(host nil)
(is-ip6 nil)
(port nil)
(path-components '())
(query nil)
(fragment nil)
;; namespace identifier, for urn parsing only:
(nid nil))
(declare (fixnum state start end))
(flet ((read-token (kind &optional legal-chars)
(setq tokval nil)
(if* (>= start end)
then :end
else (let ((sindex start)
(res nil)
c)
(declare (fixnum sindex))
(setq res
(loop
(when (>= start end) (return nil))
(setq c (char string start))
(let ((ci (char-int c)))
(if* legal-chars
then (if* (and (eq :colon kind) (eq c #\:))
then (return :colon)
elseif (= 0 (sbit legal-chars ci))
then (.parse-error
"~
URI ~s contains illegal character ~s at position ~d."
string c start))
elseif (and (< ci 128)
*strict-parse*
(= 1 (sbit illegal-chars ci)))
then (.parse-error "~
URI ~s contains illegal character ~s at position ~d."
string c start)))
(case kind
(:path (case c
(#\? (return :question))
(#\# (return :hash))))
(:query (case c (#\# (return :hash))))
(:ip6 (case c
(#\] (return :close-bracket))))
(:rest)
(t (case c
(#\: (return :colon))
(#\? (return :question))
(#\[ (return :open-bracket))
(#\] (return :close-bracket))
(#\# (return :hash))
(#\/ (return :slash)))))
(incf start)))
(if* (> start sindex)
then ;; we found some chars
;; before we stopped the parse
(setq tokval (subseq string sindex start))
:string
else ;; immediately stopped at a special char
(incf start)
res))))
(failure (&optional why)
(.parse-error "illegal URI: ~s [~d]~@[: ~a~]"
string state why))
(impossible ()
(.parse-error "impossible state: ~d [~s]" state string)))
(loop
(case state
(0 ;; starting to parse
(ecase (read-token t)
(:colon (failure))
(:question (setq state 7))
(:hash (setq state 8))
(:slash (setq state 3))
(:string (setq state 1))
(:end (setq state 9))))
(1 ;; seen <token><special char>
(let ((token tokval))
(ecase (read-token t)
(:colon (setq scheme token)
(if* (equalp "urn" scheme)
then (setq state 15)
else (setq state 2)))
(:question (push token path-components)
(setq state 7))
(:hash (push token path-components)
(setq state 8))
(:slash (push token path-components)
(push "/" path-components)
(setq state 6))
(:string (failure))
(:end (push token path-components)
(setq state 9)))))
(2 ;; seen <scheme>:
(ecase (read-token t)
(:colon (failure))
(:question (setq state 7))
(:hash (setq state 8))
(:slash (setq state 3))
(:string (setq state 10))
(:end (setq state 9))))
(10 ;; seen <scheme>:<token>
(let ((token tokval))
(ecase (read-token t)
(:colon (failure))
(:question (push token path-components)
(setq state 7))
(:hash (push token path-components)
(setq state 8))
(:slash (push token path-components)
(setq state 6))
(:string (failure))
(:end (push token path-components)
(setq state 9)))))
(3 ;; seen / or <scheme>:/
(ecase (read-token t)
(:colon (failure))
(:question (push "/" path-components)
(setq state 7))
(:hash (push "/" path-components)
(setq state 8))
(:slash (setq state 4))
(:string (push "/" path-components)
(push tokval path-components)
(setq state 6))
(:end (push "/" path-components)
(setq state 9))))
(66 ;; seen [<scheme>:]//[
(ecase (read-token :ip6 *valid-ip6-characters*)
(:string (setq host tokval)
(setq is-ip6 t)
(setq state 67))))
(67 ;; seen [<scheme>:]//[ip6]
(ecase (read-token t)
(:close-bracket (setq state 11))))
(4 ;; seen [<scheme>:]//
(ecase (read-token t)
(:colon (failure))
(:question (failure))
(:hash (failure))
(:open-bracket (setq state 66))
(:slash
(if* (and (equalp "file" scheme)
(null host))
then ;; file:///...
(push "/" path-components)
(setq state 6)
else (failure)))
(:string (setq host tokval)
(setq state 11))
(:end (failure))))
(11 ;; seen [<scheme>:]//<host>
(ecase (read-token t)
(:colon (setq state 5))
(:question (setq state 7))
(:hash (setq state 8))
(:slash (push "/" path-components)
(setq state 6))
(:string (impossible))
(:end (setq state 9))))
(5 ;; seen [<scheme>:]//<host>:
(ecase (read-token t)
(:colon (failure))
(:question (failure))
(:hash (failure))
(:slash (push "/" path-components)
(setq state 6))
(:string (setq port tokval)
(setq state 12))
(:end (failure))))
(12 ;; seen [<scheme>:]//<host>:[<port>]
(ecase (read-token t)
(:colon (failure))
(:question (setq state 7))
(:hash (setq state 8))
(:slash (push "/" path-components)
(setq state 6))
(:string (impossible))
(:end (setq state 9))))
(6 ;; seen /
(ecase (read-token :path)
(:question (setq state 7))
(:hash (setq state 8))
(:string (push tokval path-components)
(setq state 13))
(:end (setq state 9))))
(13 ;; seen path
(ecase (read-token :path)
(:question (setq state 7))
(:hash (setq state 8))
(:string (impossible))
(:end (setq state 9))))
(7 ;; seen ?
(setq illegal-chars
(if* *strict-parse*
then *strict-illegal-query-characters*
else *illegal-query-characters*))
(ecase (prog1 (read-token :query)
(setq illegal-chars *illegal-characters*))
(:hash (setq state 8))
(:string (setq query tokval)
(setq state 14))
(:end (setq state 9))))
(14 ;; query
(ecase (read-token :query)
(:hash (setq state 8))
(:string (impossible))
(:end (setq state 9))))
(8 ;; seen #
(ecase (read-token :rest)
(:string (setq fragment tokval)
(setq state 9))
(:end (setq state 9))))
(9 ;; done
(return
(values
scheme host port
(apply #'concatenate 'string (nreverse path-components))
query fragment is-ip6)))
;; URN parsing:
(15 ;; seen urn:, read nid now
(case (read-token :colon *valid-nid-characters*)
(:string (setq nid tokval)
(setq state 16))
(t (failure "missing namespace identifier"))))
(16 ;; seen urn:<nid>
(case (read-token t)
(:colon (setq state 17))
(t (failure "missing namespace specific string"))))
(17 ;; seen urn:<nid>:, rest is nss
(return (values scheme
nid
nil
(progn
(setq illegal-chars *reserved-nss-characters*)
(read-token :rest)
tokval))))
(t (.parse-error
"internal error in parse engine, wrong state: ~s." state)))))))
(defun escape-p (string)
(declare (optimize (speed 3)))
(do* ((i 0 (1+ i))
(max (the fixnum (length string))))
((= i max) nil)
(declare (fixnum i max))
(when (char= #\% (char string i))
(return t))))
(defun parse-path (path-string escape)
(do* ((xpath-list (delimited-string-to-list path-string #\/))
(path-list
(progn
(if* (string= "" (car xpath-list))
then (setf (car xpath-list) :absolute)
else (push :relative xpath-list))
xpath-list))
(pl (cdr path-list) (cdr pl))
segments)
((null pl) path-list)
(if* (cdr (setq segments
(if* (string= "" (car pl))
then '("")
else (delimited-string-to-list (car pl) #\;))))
then ;; there is a param
(setf (car pl)
(mapcar #'(lambda (s)
(decode-escaped-encoding s escape
;; decode all %xx:
nil))
segments))
else ;; no param
(setf (car pl)
(decode-escaped-encoding (car segments) escape
;; decode all %xx:
nil)))))
(defun decode-escaped-encoding (string escape
&optional (reserved-chars
*reserved-characters*))
;; Return a string with the real characters.
(when (null escape) (return-from decode-escaped-encoding string))
(do* ((i 0 (1+ i))
(max (length string))
(new-string (copy-seq string))
(new-i 0 (1+ new-i))
ch ch2 chc chc2)
((= i max)
(shrink-vector new-string new-i))
(if* (char= #\% (setq ch (char string i)))
then (when (> (+ i 3) max)
(.parse-error
"Unsyntactic escaped encoding in ~s." string))
(setq ch (char string (incf i)))
(setq ch2 (char string (incf i)))
(when (not (and (setq chc (digit-char-p ch 16))
(setq chc2 (digit-char-p ch2 16))))
(.parse-error
"Non-hexidecimal digits after %: %c%c." ch ch2))
(let ((ci (+ (* 16 chc) chc2)))
(if* (or (null reserved-chars)
(> ci 127) ; bug11527
(= 0 (sbit reserved-chars ci)))
then ;; ok as is
(setf (char new-string new-i)
(code-char ci))
else (setf (char new-string new-i) #\%)
(setf (char new-string (incf new-i)) ch)
(setf (char new-string (incf new-i)) ch2)))
else (setf (char new-string new-i) ch))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Printing
(defun render-uri (uri stream
&aux (escape (uri-escaped uri))
(*print-pretty* nil))
(when (null (uri-string uri))
(setf (uri-string uri)
(let ((scheme (uri-scheme uri))
(host (uri-host uri))
(is-ip6 (uri-is-ip6 uri))
(port (uri-port uri))
(path (uri-path uri))
(query (uri-query uri))
(fragment (uri-fragment uri)))
(concatenate 'string
(when scheme
(encode-escaped-encoding
(string-downcase ;; for upper case lisps
(symbol-name scheme))
*reserved-characters* escape))
(when scheme ":")
(when (or host (eq :file scheme)) "//")
(when is-ip6 "[")
(when host
(encode-escaped-encoding
host *reserved-authority-characters* escape))
(when is-ip6 "]")
(when port ":")
(when port
#-allegro (format nil "~D" port)
#+allegro (with-output-to-string (s)
(excl::maybe-print-fast s port))
)
(encode-escaped-encoding (or path "/")
nil
;;*reserved-path-characters*
escape)
(when query "?")
(when query (encode-escaped-encoding query nil escape))
(when fragment "#")
(when fragment (encode-escaped-encoding fragment nil escape))))))
(if* stream
then (format stream "~a" (uri-string uri))
else (uri-string uri)))
(defun render-parsed-path (path-list escape)
(do* ((res '())
(first (car path-list))
(pl (cdr path-list) (cdr pl))
(pe (car pl) (car pl)))
((null pl)
(when res (apply #'concatenate 'string (nreverse res))))
(when (or (null first)
(prog1 (eq :absolute first)
(setq first nil)))
(push "/" res))
(if* (atom pe)
then (push
(encode-escaped-encoding pe *reserved-path-characters* escape)
res)
else ;; contains params
(push (encode-escaped-encoding
(car pe) *reserved-path-characters* escape)
res)
(dolist (item (cdr pe))
(push ";" res)
(push (encode-escaped-encoding
item *reserved-path-characters* escape)
res)))))
(defun render-urn (urn stream
&aux (*print-pretty* nil))
(when (null (uri-string urn))
(setf (uri-string urn)
(let ((nid (urn-nid urn))
(nss (urn-nss urn)))
(concatenate 'string "urn:" nid ":" nss))))
(if* stream
then (format stream "~a" (uri-string urn))
else (uri-string urn)))
(defparameter *escaped-encoding*
(vector #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9 #\a #\b #\c #\d #\e #\f))
(defun encode-escaped-encoding (string reserved-chars escape)
(when (null escape) (return-from encode-escaped-encoding string))
;; Make a string as big as it possibly needs to be (3 times the original
;; size), and truncate it at the end.
(do* ((max (length string))
(new-max (* 3 max)) ;; worst case new size
(new-string (make-string new-max))
(i 0 (1+ i))
(new-i -1)
c ci)
((= i max)
(shrink-vector new-string (incf new-i)))
(setq ci (char-int (setq c (char string i))))
(if* (or (null reserved-chars)
(> ci 127)
(= 0 (sbit reserved-chars ci)))
then ;; ok as is
(incf new-i)
(setf (char new-string new-i) c)
else ;; need to escape it
(multiple-value-bind (q r) (truncate ci 16)
(setf (char new-string (incf new-i)) #\%)
(setf (char new-string (incf new-i)) (elt *escaped-encoding* q))
(setf (char new-string (incf new-i))
(elt *escaped-encoding* r))))))
(defmethod print-object ((uri uri) stream)
(if* *print-escape*
then (print-unreadable-object (uri stream :type t) (render-uri uri stream))
else (render-uri uri stream)))
(defmethod print-object ((urn urn) stream)
(if* *print-escape*
then (print-unreadable-object (urn stream :type t) (render-urn urn stream))
else (render-urn urn stream)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; merging and unmerging
(defmethod merge-uris ((uri string) (base string) &optional place)
(merge-uris (parse-uri uri) (parse-uri base) place))
(defmethod merge-uris ((uri uri) (base string) &optional place)
(merge-uris uri (parse-uri base) place))
(defmethod merge-uris ((uri string) (base uri) &optional place)
(merge-uris (parse-uri uri) base place))
(defmethod merge-uris ((uri uri) (base uri) &optional place)
;; See ../doc/rfc2396.txt for info on the algorithm we use to merge
;; URIs.
;;
(tagbody
;;;; step 2
(when (and (null (uri-parsed-path uri))
(null (uri-scheme uri))
(null (uri-host uri))
(null (uri-port uri))
(null (uri-query uri)))
(return-from merge-uris
(let ((new (copy-uri base :place place)))
(when (uri-query uri)
(setf (uri-query new) (uri-query uri)))
(when (uri-fragment uri)
(setf (uri-fragment new) (uri-fragment uri)))
new)))
(setq uri (copy-uri uri :place place))
;;;; step 3
(when (uri-scheme uri)
(return-from merge-uris uri))
(setf (uri-scheme uri) (uri-scheme base))
;;;; step 4
(when (uri-host uri) (go :done))
(setf (uri-host uri) (uri-host base))
(setf (uri-port uri) (uri-port base))
;;;; step 5
(let ((p (uri-parsed-path uri)))
;; bug13133:
;; The following form causes our implementation to be at odds with
;; RFC 2396, however this is apparently what was intended by the
;; authors of the RFC. Specifically, (merge-uris "?y" "/foo")
;; should return #<uri /foo?y> instead of #<uri ?y>, according to
;; this:
;;; http://www.apache.org/~fielding/uri/rev-2002/issues.html#003-relative-query
(when (null p)
(setf (uri-path uri) (uri-path base))
(go :done))
(when (and p (eq :absolute (car p)))
(when (equal '(:absolute "") p)
;; Canonicalize the way parsing does:
(setf (uri-path uri) nil))
(go :done)))
;;;; step 6
(let* ((base-path
(or (uri-parsed-path base)
;; needed because we canonicalize away a path of just `/':
'(:absolute "")))
(path (uri-parsed-path uri))
new-path-list)
(when (not (eq :absolute (car base-path)))
(error "Cannot merge ~a and ~a, since latter is not absolute."
uri base))
;; steps 6a and 6b:
(setq new-path-list
(append (butlast base-path)
(if* path then (cdr path) else '(""))))
;; steps 6c and 6d:
(let ((last (last new-path-list)))
(if* (atom (car last))
then (when (string= "." (car last))
(setf (car last) ""))
else (when (string= "." (caar last))
(setf (caar last) ""))))
(setq new-path-list
(delete "." new-path-list :test #'(lambda (a b)
(if* (atom b)
then (string= a b)
else nil))))
;; steps 6e and 6f:
(let ((npl (cdr new-path-list))
index tmp fix-tail)
(setq fix-tail
(string= ".." (let ((l (car (last npl))))
(if* (atom l)
then l
else (car l)))))
(loop
(setq index
(position ".." npl
:test #'(lambda (a b)
(string= a
(if* (atom b)
then b
else (car b))))))
(when (null index) (return))
(when (= 0 index)
;; The RFC says, in 6g, "that the implementation may handle
;; this error by retaining these components in the resolved
;; path, by removing them from the resolved path, or by
;; avoiding traversal of the reference." The examples in C.2
;; imply that we should do the first thing (retain them), so
;; that's what we'll do.
(return))
(if* (= 1 index)
then (setq npl (cddr npl))
else (setq tmp npl)
(dotimes (x (- index 2)) (setq tmp (cdr tmp)))
(setf (cdr tmp) (cdddr tmp))))
(setf (cdr new-path-list) npl)
(when fix-tail (setq new-path-list (nconc new-path-list '("")))))
;; step 6g:
;; don't complain if new-path-list starts with `..'. See comment
;; above about this step.
;; step 6h:
(when (or (equal '(:absolute "") new-path-list)
(equal '(:absolute) new-path-list))
(setq new-path-list nil))
(setf (uri-path uri)
(render-parsed-path new-path-list
;; don't know, so have to assume:
t)))
;;;; step 7
:done
(return-from merge-uris uri)))
(defmethod enough-uri ((uri string) (base string) &optional place)
(enough-uri (parse-uri uri) (parse-uri base) place))
(defmethod enough-uri ((uri uri) (base string) &optional place)
(enough-uri uri (parse-uri base) place))
(defmethod enough-uri ((uri string) (base uri) &optional place)
(enough-uri (parse-uri uri) base place))
(defmethod enough-uri ((uri uri) (base uri) &optional place)
(let ((new-scheme nil)
(new-host nil)
(new-port nil)
(new-parsed-path nil))
(when (or (and (uri-scheme uri)
(not (equalp (uri-scheme uri) (uri-scheme base))))
(and (uri-host uri)
(not (equalp (uri-host uri) (uri-host base))))
(not (equalp (uri-port uri) (uri-port base))))
(return-from enough-uri uri))
(when (null (uri-host uri))
(setq new-host (uri-host base)))
(when (null (uri-port uri))
(setq new-port (uri-port base)))
(when (null (uri-scheme uri))
(setq new-scheme (uri-scheme base)))
;; Now, for the hard one, path.
;; We essentially do here what enough-namestring does.
(do* ((base-path (uri-parsed-path base))
(path (uri-parsed-path uri))
(bp base-path (cdr bp))
(p path (cdr p)))
((or (null bp) (null p))
;; If p is nil, that means we have something like
;; (enough-uri "/foo/bar" "/foo/bar/baz.htm"), so
;; new-parsed-path will be nil.
(when (null bp)
(setq new-parsed-path (copy-list p))
(when (not (symbolp (car new-parsed-path)))
(push :relative new-parsed-path))))
(if* (equal (car bp) (car p))
thenret ;; skip it
else (setq new-parsed-path (copy-list p))
(when (not (symbolp (car new-parsed-path)))
(push :relative new-parsed-path))
(return)))
(let ((new-path
(when new-parsed-path
(render-parsed-path new-parsed-path
;; don't know, so have to assume:
t)))
(new-query (uri-query uri))
(new-fragment (uri-fragment uri))
(new-plist (copy-list (uri-plist uri))))
(if* (and (null new-scheme)
(null new-host)
(null new-port)
(null new-path)
(null new-parsed-path)
(null new-query)
(null new-fragment))
then ;; can't have a completely empty uri!
(copy-uri nil
:class (class-of uri)
:place place
:path "/"
:plist new-plist)
else (copy-uri nil
:class (class-of uri)
:place place
:scheme new-scheme
:host new-host
:port new-port
:path new-path
:parsed-path new-parsed-path
:query new-query
:fragment new-fragment
:plist new-plist)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; support for interning URIs
(defun make-uri-space (&rest keys &key (size 777) &allow-other-keys)
#+allegro
(apply #'make-hash-table :size size
:hash-function 'uri-hash
:test 'uri= :values nil keys)
#-allegro
(apply #'make-hash-table :size size keys))
(defun gethash-uri (uri table)
#+allegro (gethash uri table)
#-allegro
(let* ((hash (uri-hash uri))
(existing (gethash hash table)))
(dolist (u existing)
(when (uri= u uri)
(return-from gethash-uri (values u t))))
(values nil nil)))
(defun puthash-uri (uri table)
#+allegro (excl:puthash-key uri table)
#-allegro
(let ((existing (gethash (uri-hash uri) table)))
(dolist (u existing)
(when (uri= u uri)
(return-from puthash-uri u)))
(setf (gethash (uri-hash uri) table)
(cons uri existing))
uri))
(defun uri-hash (uri)
(if* (uri-hashcode uri)
thenret
else (setf (uri-hashcode uri)
(sxhash
#+allegro
(render-uri uri nil)
#-allegro
(string-downcase
(render-uri uri nil))))))
(defvar *uris* (make-uri-space))
(defun uri-space () *uris*)
(defun (setf uri-space) (new-val)
(setq *uris* new-val))
;; bootstrapping (uri= changed from function to method):
(when (fboundp 'uri=) (fmakunbound 'uri=))
(defgeneric uri= (uri1 uri2))
(defmethod uri= ((uri1 uri) (uri2 uri))
(when (not (eq (uri-scheme uri1) (uri-scheme uri2)))
(return-from uri= nil))
;; RFC2396 says: a URL with an explicit ":port", where the port is
;; the default for the scheme, is the equivalent to one where the
;; port is elided. Hmmmm. This means that this function has to be
;; scheme dependent. Grrrr.
(let ((default-port (case (uri-scheme uri1)
(:http 80)
(:https 443)
(:ftp 21)
(:telnet 23))))
(and (equalp (uri-host uri1) (uri-host uri2))
(eql (or (uri-port uri1) default-port)
(or (uri-port uri2) default-port))
(string= (uri-path uri1) (uri-path uri2))
(string= (uri-query uri1) (uri-query uri2))
(string= (uri-fragment uri1) (uri-fragment uri2)))))
(defmethod uri= ((urn1 urn) (urn2 urn))
(when (not (eq (uri-scheme urn1) (uri-scheme urn2)))
(return-from uri= nil))
(and (equalp (urn-nid urn1) (urn-nid urn2))
(urn-nss-equal (urn-nss urn1) (urn-nss urn2))))
(defun urn-nss-equal (nss1 nss2 &aux len)
;; Return t iff the nss values are the same.
;; %2c and %2C are equivalent.
(when (or (null nss1) (null nss2)
(not (= (setq len (length nss1))
(length nss2))))
(return-from urn-nss-equal nil))
(do* ((i 0 (1+ i))
(state :char)
c1 c2)
((= i len) t)
(setq c1 (char nss1 i))
(setq c2 (char nss2 i))
(ecase state
(:char
(if* (and (char= #\% c1) (char= #\% c2))
then (setq state :percent+1)
elseif (char/= c1 c2)
then (return nil)))
(:percent+1
(when (char-not-equal c1 c2) (return nil))
(setq state :percent+2))
(:percent+2
(when (char-not-equal c1 c2) (return nil))
(setq state :char)))))
(defmethod intern-uri ((xuri uri) &optional (uri-space *uris*))
(let ((uri (gethash-uri xuri uri-space)))
(if* uri
thenret
else (puthash-uri xuri uri-space))))
(defmethod intern-uri ((uri string) &optional (uri-space *uris*))
(intern-uri (parse-uri uri) uri-space))
(defun unintern-uri (uri &optional (uri-space *uris*))
(if* (eq t uri)
then (clrhash uri-space)
elseif (uri-p uri)
then (remhash uri uri-space)
else (error "bad uri: ~s." uri)))
(defmacro do-all-uris ((var &optional uri-space result-form)
&rest forms
&environment env)
"do-all-uris (var [[uri-space] result-form])
{declaration}* {tag | statement}*
Executes the forms once for each uri with var bound to the current uri"
(let ((f (gensym))
(g-ignore (gensym))
(g-uri-space (gensym))
(body (third (parse-body forms env))))
`(let ((,g-uri-space (or ,uri-space *uris*)))
(prog nil
(flet ((,f (,var &optional ,g-ignore)
(declare (ignore-if-unused ,var ,g-ignore))
(tagbody ,@body)))
(maphash #',f ,g-uri-space))
(return ,result-form)))))
(defun sharp-u (stream chr arg)
(declare (ignore chr arg))
(let ((arg (read stream nil nil t)))
(if *read-suppress*
nil
(if* (stringp arg)
then (parse-uri arg)
else
(internal-reader-error
stream
"#u takes a string or list argument: ~s" arg)))))
(set-dispatch-macro-character #\# #\u #'puri::sharp-u)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(provide :uri)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; timings
;; (don't run under emacs with M-x fi:common-lisp)
#+allegro
(eval-when (:compile-toplevel :load-toplevel :execute)
(import 'excl::gc))
#-allegro
(defun gc (&rest options)
(declare (ignore options))
#+sbcl (sb-ext::gc)
#+cmu (ext::gc)
)
(defun time-uri-module ()
(declare (optimize (speed 3) (safety 0) (debug 0)))
(let ((uri "http://www.franz.com/a/b;x;y;z/c/foo?bar=baz&xxx#foo")
(uri2 "http://www.franz.com/a/b;x;y;z/c/%2ffoo?bar=baz&xxx#foo"))
(gc t) (gc :tenure) (gc :tenure) (gc :tenure)
(format t "~&;;; starting timing testing 1...~%")
(time (dotimes (i 100000) (parse-uri uri)))
(gc t) (gc :tenure) (gc :tenure) (gc :tenure)
(format t "~&;;; starting timing testing 2...~%")
(let ((uri (parse-uri uri)))
(time (dotimes (i 100000)
;; forces no caching of the printed representation:
(setf (uri-string uri) nil)
(format nil "~a" uri))))
(gc t) (gc :tenure) (gc :tenure) (gc :tenure)
(format t "~&;;; starting timing testing 3...~%")
(time
(progn
(dotimes (i 100000) (parse-uri uri2))
(let ((uri (parse-uri uri)))
(dotimes (i 100000)
;; forces no caching of the printed representation:
(setf (uri-string uri) nil)
(format nil "~a" uri)))))))
;;******** reference output (ultra, modified 5.0.1):
;;; starting timing testing 1...
; cpu time (non-gc) 13,710 msec user, 0 msec system
; cpu time (gc) 600 msec user, 10 msec system
; cpu time (total) 14,310 msec user, 10 msec system
; real time 14,465 msec
; space allocation:
; 1,804,261 cons cells, 7 symbols, 41,628,832 other bytes, 0 static bytes
;;; starting timing testing 2...
; cpu time (non-gc) 27,500 msec user, 0 msec system
; cpu time (gc) 280 msec user, 20 msec system
; cpu time (total) 27,780 msec user, 20 msec system
; real time 27,897 msec
; space allocation:
; 1,900,463 cons cells, 0 symbols, 17,693,712 other bytes, 0 static bytes
;;; starting timing testing 3...
; cpu time (non-gc) 52,290 msec user, 10 msec system
; cpu time (gc) 1,290 msec user, 30 msec system
; cpu time (total) 53,580 msec user, 40 msec system
; real time 54,062 msec
; space allocation:
; 7,800,205 cons cells, 0 symbols, 81,697,496 other bytes, 0 static bytes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; after improving decode-escaped-encoding/encode-escaped-encoding:
;;; starting timing testing 1...
; cpu time (non-gc) 14,520 msec user, 0 msec system
; cpu time (gc) 400 msec user, 0 msec system
; cpu time (total) 14,920 msec user, 0 msec system
; real time 15,082 msec
; space allocation:
; 1,800,270 cons cells, 0 symbols, 41,600,160 other bytes, 0 static bytes
;;; starting timing testing 2...
; cpu time (non-gc) 27,490 msec user, 10 msec system
; cpu time (gc) 300 msec user, 0 msec system
; cpu time (total) 27,790 msec user, 10 msec system
; real time 28,025 msec
; space allocation:
; 1,900,436 cons cells, 0 symbols, 17,693,712 other bytes, 0 static bytes
;;; starting timing testing 3...
; cpu time (non-gc) 47,900 msec user, 20 msec system
; cpu time (gc) 920 msec user, 10 msec system
; cpu time (total) 48,820 msec user, 30 msec system
; real time 49,188 msec
; space allocation:
; 3,700,215 cons cells, 0 symbols, 81,707,144 other bytes, 0 static bytes
| 52,933 | Common Lisp | .lisp | 1,318 | 29.127466 | 80 | 0.511936 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | bf8bfbc83490fe636b2c44687a57a38e5913b76f1a9313a00e5244a507ea8191 | 43,036 | [
-1
] |
43,037 | tests.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/puri-20201016-git/tests.lisp | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*-
;; copyright (c) 1999-2001 Franz Inc, Berkeley, CA - All rights reserved.
;; copyright (c) 2003 Kevin Rosenberg (significant fixes for using
;; tester package)
;;
;; The software, data and information contained herein are proprietary
;; to, and comprise valuable trade secrets of, Franz, Inc. They are
;; given in confidence by Franz, Inc. pursuant to a written license
;; agreement, and may be stored and used only in accordance with the terms
;; of such license.
;;
;; Restricted Rights Legend
;; ------------------------
;; Use, duplication, and disclosure of the software, data and information
;; contained herein by any agency, department or entity of the U.S.
;; Government are subject to restrictions of Restricted Rights for
;; Commercial Software developed at private expense as specified in
;; DOD FAR Supplement 52.227-7013 (c) (1) (ii), as applicable.
;;
;; Original version from ACL 6.1:
;; t-uri.cl,v 1.3.6.3.2.1 2001/08/09 17:42:43 layer
;;
;; $Id$
(defpackage #:puri/test (:use #:puri #:cl #:ptester))
(in-package #:puri/test)
(unintern-uri t)
(defmacro gen-test-forms ()
(let ((res '())
(base-uri "http://a/b/c/d;p?q"))
(dolist (x `(;; (relative-uri result base-uri compare-function)
;;;; RFC Appendix C.1 (normal examples)
("g:h" "g:h" ,base-uri)
("g" "http://a/b/c/g" ,base-uri)
("./g" "http://a/b/c/g" ,base-uri)
("g/" "http://a/b/c/g/" ,base-uri)
("/g" "http://a/g" ,base-uri)
("//g" "http://g" ,base-uri)
;; Following was changed from appendix C of RFC 2396
;; http://www.apache.org/~fielding/uri/rev-2002/issues.html#003-relative-query
#-ignore ("?y" "http://a/b/c/d;p?y" ,base-uri)
#+ignore ("?y" "http://a/b/c/?y" ,base-uri)
("g?y" "http://a/b/c/g?y" ,base-uri)
("#s" "http://a/b/c/d;p?q#s" ,base-uri)
("g#s" "http://a/b/c/g#s" ,base-uri)
("g?y#s" "http://a/b/c/g?y#s" ,base-uri)
(";x" "http://a/b/c/;x" ,base-uri)
("g;x" "http://a/b/c/g;x" ,base-uri)
("g;x?y#s" "http://a/b/c/g;x?y#s" ,base-uri)
("." "http://a/b/c/" ,base-uri)
("./" "http://a/b/c/" ,base-uri)
(".." "http://a/b/" ,base-uri)
("../" "http://a/b/" ,base-uri)
("../g" "http://a/b/g" ,base-uri)
("../.." "http://a/" ,base-uri)
("../../" "http://a/" ,base-uri)
("../../g" "http://a/g" ,base-uri)
;;;; RFC Appendix C.2 (abnormal examples)
("" "http://a/b/c/d;p?q" ,base-uri)
("../../../g" "http://a/../g" ,base-uri)
("../../../../g" "http://a/../../g" ,base-uri)
("/./g" "http://a/./g" ,base-uri)
("/../g" "http://a/../g" ,base-uri)
("g." "http://a/b/c/g." ,base-uri)
(".g" "http://a/b/c/.g" ,base-uri)
("g.." "http://a/b/c/g.." ,base-uri)
("..g" "http://a/b/c/..g" ,base-uri)
("./../g" "http://a/b/g" ,base-uri)
("./g/." "http://a/b/c/g/" ,base-uri)
("g/./h" "http://a/b/c/g/h" ,base-uri)
("g/../h" "http://a/b/c/h" ,base-uri)
("g;x=1/./y" "http://a/b/c/g;x=1/y" ,base-uri)
("g;x=1/../y" "http://a/b/c/y" ,base-uri)
("g?y/./x" "http://a/b/c/g?y/./x" ,base-uri)
("g?y/../x" "http://a/b/c/g?y/../x" ,base-uri)
("g#s/./x" "http://a/b/c/g#s/./x" ,base-uri)
("g#s/../x" "http://a/b/c/g#s/../x" ,base-uri)
("http:g" "http:g" ,base-uri)
("foo/bar/baz.htm#foo"
"http://a/b/foo/bar/baz.htm#foo"
"http://a/b/c.htm")
("foo/bar/baz.htm#foo"
"http://a/b/foo/bar/baz.htm#foo"
"http://a/b/")
("foo/bar/baz.htm#foo"
"http://a/foo/bar/baz.htm#foo"
"http://a/b")
("foo/bar;x;y/bam.htm"
"http://a/b/c/foo/bar;x;y/bam.htm"
"http://a/b/c/")))
(push `(test (intern-uri ,(second x))
(intern-uri (merge-uris (intern-uri ,(first x))
(intern-uri ,(third x))))
:test 'uri=)
res))
;;;; intern tests
(dolist (x '(;; default port and specifying the default port are
;; supposed to compare the same:
("http://www.franz.com:80" "http://www.franz.com")
("http://www.franz.com:80" "http://www.franz.com" eq)
;; make sure they're `eq':
("http://www.franz.com:80" "http://www.franz.com" eq)
("http://www.franz.com" "http://www.franz.com" eq)
("http://www.franz.com/foo" "http://www.franz.com/foo" eq)
("http://www.franz.com/foo?bar"
"http://www.franz.com/foo?bar" eq)
("http://www.franz.com/foo?bar#baz"
"http://www.franz.com/foo?bar#baz" eq)
("http://WWW.FRANZ.COM" "http://www.franz.com" eq)
("http://www.FRANZ.com" "http://www.franz.com" eq)
("http://www.franz.com" "http://www.franz.com/" eq)
(;; %72 is "r", %2f is "/", %3b is ";"
"http://www.franz.com/ba%72%2f%3b;x;y;z/baz/"
"http://www.franz.com/bar%2f%3b;x;y;z/baz/" eq)))
(push `(test (intern-uri ,(second x))
(intern-uri ,(first x))
:test ',(if (third x)
(third x)
'uri=))
res))
;;;; parsing and equivalence tests
(push `(test
(parse-uri "http://foo+bar?baz=b%26lob+bof")
(parse-uri (parse-uri "http://foo+bar?baz=b%26lob+bof"))
:test 'uri=)
res)
(push '(test
(parse-uri "http://www.foo.com")
(parse-uri (parse-uri "http://www.foo.com?")) ; allow ? at end
:test 'uri=)
res)
(push `(test
"baz=b%26lob+bof"
(uri-query (parse-uri "http://foo+bar?baz=b%26lob+bof"))
:test 'string=)
res)
(push `(test
"baz=b%26lob+bof%3d"
(uri-query (parse-uri "http://foo+bar?baz=b%26lob+bof%3d"))
:test 'string=)
res)
(push
`(test (parse-uri "xxx?%41") (parse-uri "xxx?A") :test 'uri=)
res)
(push
`(test "A" (uri-query (parse-uri "xxx?%41")) :test 'string=)
res)
(push `(test-error (parse-uri " ")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "foo ")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri " foo ")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "<foo")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "foo>")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "<foo>")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "%")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "foo%xyr")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "\"foo\"")
:condition-type 'uri-parse-error)
res)
(push `(test "%20" (format nil "~a" (parse-uri "%20"))
:test 'string=)
res)
(push `(test "&" (format nil "~a" (parse-uri "%26"))
:test 'string=)
res)
(push
`(test "foo%23bar" (format nil "~a" (parse-uri "foo%23bar"))
:test 'string=)
res)
(push
`(test "foo%23bar#foobar"
(format nil "~a" (parse-uri "foo%23bar#foobar"))
:test 'string=)
res)
(push
`(test "foo%23bar#foobar#baz"
(format nil "~a" (parse-uri "foo%23bar#foobar#baz"))
:test 'string=)
res)
(push
`(test "foo%23bar#foobar#baz"
(format nil "~a" (parse-uri "foo%23bar#foobar%23baz"))
:test 'string=)
res)
(push
`(test "foo%23bar#foobar/baz"
(format nil "~a" (parse-uri "foo%23bar#foobar%2fbaz"))
:test 'string=)
res)
(push `(test-error (parse-uri "foobar??")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "foobar?foo?")
:condition-type 'uri-parse-error)
res)
(push `(test "foobar?%3f"
(format nil "~a" (parse-uri "foobar?%3f"))
:test 'string=)
res)
(push `(test
"http://foo/bAr;3/baz?baf=3"
(format nil "~a" (parse-uri "http://foo/b%41r;3/baz?baf=3"))
:test 'string=)
res)
(push `(test
'(:absolute ("/bAr" "3") "baz")
(uri-parsed-path (parse-uri "http://foo/%2fb%41r;3/baz?baf=3"))
:test 'equal)
res)
(push `(test
"/%2fbAr;3/baz"
(let ((u (parse-uri "http://foo/%2fb%41r;3/baz?baf=3")))
(setf (uri-parsed-path u) '(:absolute ("/bAr" "3") "baz"))
(uri-path u))
:test 'string=)
res)
(push `(test
"http://www.verada.com:8010/kapow?name=foo%3Dbar%25"
(format nil "~a"
(parse-uri
"http://www.verada.com:8010/kapow?name=foo%3Dbar%25"))
:test 'string=)
res)
(push `(test
"ftp://parcftp.xerox.com/pub/pcl/mop/"
(format nil "~a"
(parse-uri "ftp://parcftp.xerox.com:/pub/pcl/mop/"))
:test 'string=)
res)
;;;; enough-uri tests
(dolist (x `(("http://www.franz.com/foo/bar/baz.htm"
"http://www.franz.com/foo/bar/"
"baz.htm")
("http://www.franz.com/foo/bar/baz.htm"
"http://www.franz.com/foo/bar"
"baz.htm")
("http://www.franz.com:80/foo/bar/baz.htm"
"http://www.franz.com:80/foo/bar"
"baz.htm")
("http:/foo/bar/baz.htm" "http:/foo/bar" "baz.htm")
("http:/foo/bar/baz.htm" "http:/foo/bar/" "baz.htm")
("/foo/bar/baz.htm" "/foo/bar" "baz.htm")
("/foo/bar/baz.htm" "/foo/bar/" "baz.htm")
("/foo/bar/baz.htm#foo" "/foo/bar/" "baz.htm#foo")
("/foo/bar/baz.htm?bar#foo" "/foo/bar/" "baz.htm?bar#foo")
("http://www.dnai.com/~layer/foo.htm"
"http://www.known.net"
"http://www.dnai.com/~layer/foo.htm")
("http://www.dnai.com/~layer/foo.htm"
"http://www.dnai.com:8000/~layer/"
"http://www.dnai.com/~layer/foo.htm")
("http://www.dnai.com:8000/~layer/foo.htm"
"http://www.dnai.com/~layer/"
"http://www.dnai.com:8000/~layer/foo.htm")
("http://www.franz.com"
"http://www.franz.com"
"/")))
(push `(test (parse-uri ,(third x))
(enough-uri (parse-uri ,(first x))
(parse-uri ,(second x)))
:test 'uri=)
res))
;;;; urn tests, ideas of which are from rfc2141
(let ((urn "urn:com:foo-the-bar"))
(push `(test "com" (urn-nid (parse-uri ,urn))
:test #'string=)
res)
(push `(test "foo-the-bar" (urn-nss (parse-uri ,urn))
:test #'string=)
res))
(push `(test-error (parse-uri "urn:")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "urn:foo")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "urn:foo$")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "urn:foo_")
:condition-type 'uri-parse-error)
res)
(push `(test-error (parse-uri "urn:foo:foo&bar")
:condition-type 'uri-parse-error)
res)
(push `(test (parse-uri "URN:foo:a123,456")
(parse-uri "urn:foo:a123,456")
:test #'uri=)
res)
(push `(test (parse-uri "URN:foo:a123,456")
(parse-uri "urn:FOO:a123,456")
:test #'uri=)
res)
(push `(test (parse-uri "urn:foo:a123,456")
(parse-uri "urn:FOO:a123,456")
:test #'uri=)
res)
(push `(test (parse-uri "URN:FOO:a123%2c456")
(parse-uri "urn:foo:a123%2C456")
:test #'uri=)
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:A123,456")
(parse-uri "urn:FOO:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:A123,456")
(parse-uri "urn:foo:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:A123,456")
(parse-uri "URN:foo:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:a123%2C456")
(parse-uri "urn:FOO:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:a123%2C456")
(parse-uri "urn:foo:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "URN:FOO:a123%2c456")
(parse-uri "urn:foo:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:FOO:a123%2c456")
(parse-uri "urn:foo:a123,456")))
res)
(push `(test
nil
(uri= (parse-uri "urn:foo:a123%2c456")
(parse-uri "urn:foo:a123,456")))
res)
(push `(test t
(uri= (parse-uri "foo") (parse-uri "foo#")))
res)
(push
'(let ((puri::*strict-parse* nil))
(test-no-error
(puri:parse-uri
"http://foo.com/bar?a=zip|zop")))
res)
(push
'(test-error
(puri:parse-uri "http://foo.com/bar?a=zip|zop")
:condition-type 'uri-parse-error)
res)
(push
'(let ((puri::*strict-parse* nil))
(test-no-error
(puri:parse-uri
"http://arc3.msn.com/ADSAdClient31.dll?GetAd?PG=NBCSBU?SC=D2?AN=1.0586041")))
res)
(push
'(test-error
(puri:parse-uri
"http://arc3.msn.com/ADSAdClient31.dll?GetAd?PG=NBCSBU?SC=D2?AN=1.0586041")
:condition-type 'uri-parse-error)
res)
(push
'(let ((puri::*strict-parse* nil))
(test-no-error
(puri:parse-uri
"http://scbc.booksonline.com/cgi-bin/ndCGI.exe/Develop/pagClubHome.hrfTIOLI_onWebEvent(hrfTIOLI)?selGetClubOffer.TB_OFFER_ID_OFFER=344879%2e0&selGetClubOffer.TB_OFFER_ID_ITEM=34487%2e0&selGetClubOffer.TB_OFFER_ID_OFFER=344879%2e0&^CSpCommand.currRowNumber=5&hrfTIOLI=The+Visual+Basic+6+Programmer%27s+Toolkit&SPIDERSESSION=%3f%3f%3f%3f%3f%5f%3f%3f%3f%40%5b%3f%3f%3f%3fBOs%5cH%3f%3f%3f%3f%3f%3f%3f%3f%3fMMpXO%5f%40JG%7d%40%5c%5f%3f%3f%3fECK%5dt%3fLDT%3fTBD%3fDDTxPEToBS%40%5f%5dBDgXVoKBSDs%7cDT%3fK%3fd%3fTIb%7ceHbkeMfh%60LRpO%5cact%5eUC%7bMu%5fyWUGzLUhP%5ebpdWRka%5dFO%3f%5dBopW%3f%40HMrxbMRd%60LOpuMVga%3fv%3fTS%3fpODT%40O&%5euniqueValue=977933764843")))
res)
(push
'(test-error
(puri:parse-uri
"http://scbc.booksonline.com/cgi-bin/ndCGI.exe/Develop/pagClubHome.hrfTIOLI_onWebEvent(hrfTIOLI)?selGetClubOffer.TB_OFFER_ID_OFFER=344879%2e0&selGetClubOffer.TB_OFFER_ID_ITEM=34487%2e0&selGetClubOffer.TB_OFFER_ID_OFFER=344879%2e0&^CSpCommand.currRowNumber=5&hrfTIOLI=The+Visual+Basic+6+Programmer%27s+Toolkit&SPIDERSESSION=%3f%3f%3f%3f%3f%5f%3f%3f%3f%40%5b%3f%3f%3f%3fBOs%5cH%3f%3f%3f%3f%3f%3f%3f%3f%3fMMpXO%5f%40JG%7d%40%5c%5f%3f%3f%3fECK%5dt%3fLDT%3fTBD%3fDDTxPEToBS%40%5f%5dBDgXVoKBSDs%7cDT%3fK%3fd%3fTIb%7ceHbkeMfh%60LRpO%5cact%5eUC%7bMu%5fyWUGzLUhP%5ebpdWRka%5dFO%3f%5dBopW%3f%40HMrxbMRd%60LOpuMVga%3fv%3fTS%3fpODT%40O&%5euniqueValue=977933764843")
:condition-type 'uri-parse-error)
res)
;;; tests for weird control characters
;; http://www.ietf.org/rfc/rfc2396.txt 2.4.3
(dolist (x '("https://example.com/q?foo%0abar%20baz" ;;an escaped newline
"https://example.com/q?%7f" ;; 7f, 127
))
(push
`(let ((weird-uri ,x))
(test weird-uri
(puri:render-uri (puri:parse-uri weird-uri) nil)
:test #'string=)
) res))
`(progn ,@(nreverse res))))
(defun do-tests ()
(let ((*break-on-test-failures* t))
(with-tests (:name "puri")
(gen-test-forms)))
t)
| 17,827 | Common Lisp | .lisp | 410 | 30.297561 | 664 | 0.474422 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | ba427b5011ad5e31ed87bfc033417966d415bf146ea64309f45ec8f5596eed57 | 43,037 | [
-1
] |
43,038 | proc-parse.lisp | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/proc-parse-20190813-git/t/proc-parse.lisp | (in-package :cl-user)
(defpackage proc-parse-test
(:use :cl
:proc-parse
:prove)
(:shadowing-import-from :proc-parse
:skip))
(in-package :proc-parse-test)
(plan 17)
(defmacro with-vector-parsing-test ((target) &body body)
`(progn
(subtest "with-string-parsing"
(with-string-parsing (,target)
(flet ((is-current (char &optional desc)
(is (current) char desc :test #'char=)))
,@body)))
(subtest "with-octets-parsing"
(with-octets-parsing (,(babel:string-to-octets target))
(flet ((is-current (char &optional desc)
(is (current) (char-code char) desc :test #'=)))
,@body)))))
(subtest "current"
(subtest "with-vector-parsing"
(with-vector-parsing ("a")
(is (current) #\a)))
(with-vector-parsing-test ("a")
(is-current #\a
"can return the current character.")))
(defmacro test-peek ((target) &body body)
`(progn
(subtest "with-vector-parsing"
(with-vector-parsing (,target) ,@body))
(subtest "with-string-parsing"
(with-string-parsing (,target) ,@body))
(subtest "with-octets-parsing"
(with-octets-parsing (,(babel:string-to-octets target)) ,@body))))
(subtest "peek"
(test-peek ("a") (is (peek) nil))
(test-peek ("a") (is (peek :eof-value 'yes) 'yes))
(subtest "with-vector-parsing"
(with-vector-parsing ("abcd")
(advance)
(is (peek) #\c)))
(subtest "with-vector-parsing"
(with-vector-parsing ("abcdefg" :end 5)
(match "abc")
(is (peek :eof-value 'yes) #\e)))
(subtest "with-vector-parsing"
(with-vector-parsing ("abcdefg" :end 5)
(match "abcd")
(is (peek :eof-value 'yes) 'yes))))
(subtest "advance"
(with-vector-parsing-test ("ab")
(advance)
(is-current #\b
"can increment the current position.")
(advance)
(fail "won't be executed after EOF")))
(subtest "advance*"
(with-vector-parsing-test ("ab")
(advance*)
(is-current #\b
"can increment the current position.")
(ok (not (advance*))
"doesn't raise the eof error without rest characters.")))
(subtest "skip"
(with-vector-parsing-test ("ab")
(skip #\a)
(is-current #\b
"can skip the spcified character.")
(is-error (skip #\c)
'match-failed
"can raise the match-failed error with unmatched character.")))
(subtest "skip*"
(with-vector-parsing-test ("aaabbb")
(skip* #\a)
(is-current #\b
"can skip some spcified character.")
(ok (not (skip* #\c))
"doesn't raise the match-failed error with unmatched character.")
(is-current #\b
"doesn't skip any characters when unmatched character spcified.")))
(subtest "skip+"
(with-vector-parsing-test ("aaabbb")
(skip+ #\a)
(is-current #\b
"can skip some spcified character.")
(is-error (skip+ #\c)
'match-failed
"can raise the match-failed error with unmatched character.")))
(subtest "skip?"
(with-vector-parsing-test ("ab")
(skip? #\a)
(is-current #\b
"can skip the spcified character.")
(ok (not (skip? #\c))
"doesn't raise the match-failed error with unmatched character.")
(is-current #\b
"doesn't skip any characters when unmatched character spcified.")))
(subtest "skip-until"
(subtest "with-vector-parsing"
(with-vector-parsing ("aaab")
(skip-until (lambda (c) (char/= c #\a)))
(is (current)
#\b
"can skip until form returns T.")
(skip-until (lambda (c) (char/= c #\c)))
(is (current)
#\b
"can skip until eof.")))
(subtest "with-string-parsing"
(with-string-parsing ("aaab")
(skip-until (lambda (c) (char/= c #\a)))
(is (current)
#\b
"can skip until form returns T.")
(skip-until (lambda (c) (char/= c #\c)))
(is (current)
#\b
"can skip until eof.")))
(subtest "with-octets-parsing"
(with-octets-parsing ((babel:string-to-octets "aaab"))
(skip-until (lambda (b) (/= b (char-code #\a))))
(is (current) (char-code #\b)
"can skip until form returns T.")
(skip-until (lambda (b) (/= b (char-code #\c))))
(is (current) (char-code #\b)
"can skip until eof."))))
(subtest "skip-while"
(subtest "with-vector-parsing"
(with-vector-parsing ("aaab")
(skip-while (lambda (c) (char= c #\a)))
(is (current)
#\b
"can skip when form returns T.")
(skip-while (lambda (c) (char= c #\b)))
(is (current)
#\b
"can skip until eof.")))
(subtest "with-string-parsing"
(with-string-parsing ("aaab")
(skip-while (lambda (c) (char= c #\a)))
(is (current)
#\b
"can skip when form returns T.")
(skip-while (lambda (c) (char= c #\b)))
(is (current)
#\b
"can skip until eof.")))
(subtest "with-octets-parsing"
(with-octets-parsing ((babel:string-to-octets "aaab"))
(skip-while (lambda (b) (= b (char-code #\a))))
(is (current) (char-code #\b)
"can skip when form returns T.")
(skip-while (lambda (b) (= b (char-code #\b))))
(is (current) (char-code #\b)
"can skip until eof."))))
(defun alpha-char-byte-p (byte)
(or (<= (char-code #\a) byte (char-code #\z))
(<= (char-code #\A) byte (char-code #\Z))))
(subtest "bind"
(subtest "with-vector-parsing"
(with-vector-parsing ("aaab")
(bind (str1 (skip-while (lambda (c) (char= c #\a))))
(is str1
"aaa"
"can bind string with form."))
(bind (str2 (skip-while (lambda (c) (char= c #\b))))
(is str2
"b"
"can bind string until eof.")))
(with-vector-parsing ("a123")
(skip-while alpha-char-p)
(bind (num (skip-until alpha-char-p))
(is num "123" "can bind even when reached to EOF"))))
(subtest "with-string-parsing"
(with-string-parsing ("aaab")
(bind (str1 (skip-while (lambda (c) (char= c #\a))))
(is str1
"aaa"
"can bind string with form."))
(bind (str2 (skip-while (lambda (c) (char= c #\b))))
(is str2
"b"
"can bind string until eof.")))
(with-string-parsing ("a123")
(skip-while alpha-char-p)
(bind (num (skip-until alpha-char-p))
(is num "123" "can bind even when reached to EOF"))))
(subtest "with-octets-parsing"
(with-octets-parsing ((babel:string-to-octets "aaab"))
(bind (bytes1 (skip-while (lambda (b) (= b (char-code #\a)))))
(is bytes1
(babel:string-to-octets "aaa")
"can bind octets with form."
:test #'equalp))
(bind (bytes2 (skip-while (lambda (b) (= b (char-code #\b)))))
(is bytes2
(babel:string-to-octets "b")
"can bind octets until eof."
:test #'equalp)))
(with-octets-parsing ((babel:string-to-octets "a123"))
(skip-while alpha-char-byte-p)
(bind (num (skip-until alpha-char-byte-p))
(is num (babel:string-to-octets "123")
"can bind even when reached to EOF"
:test #'equalp)))))
(subtest "match"
(with-vector-parsing-test ("abc")
(match "cd" "ab")
(is-current #\c
"can skip the matched one of specified strings.")
(is-error (match "e" "fg")
'match-failed
"can raise the match-failed error with unmatched strings.")))
(subtest "match-i"
(with-vector-parsing-test ("ABC")
(match-i "cd" "ab")
(is-current #\C
"can skip the case-insensitively matched one of specified strings.")
(is-error (match-i "e")
'match-failed
"can raise the match-failed error with case-insensitively unmatched strings.")))
(subtest "match?"
(with-vector-parsing-test ("abc")
(match? "ab")
(is-current #\c
"can skip the matched one of specified strings.")
(match? "de")
(is-current #\c
"doesn't raise the match-failed error with unmatched strings.")))
(subtest "match-case"
(with-vector-parsing-test ("abc")
(is (match-case
("a" 0)
("b" 1))
0
"can return the value the body form of the matched case returns.")
(is (match-case
("c" 0)
(otherwise 1))
1
"can return the value the otherwise form returns.")
(is-error (match-case
("c"))
'match-failed
"can raise the match-failed error with unmatched cases.")
(is (match-case
("bc" 0))
0
"can return the value the body form of the matched case returns even thogh eof.")))
(subtest "match-i-case"
(with-vector-parsing-test ("ABC")
(is (match-i-case
("a" 0)
("b" 1))
0
"can return the value the body form of the case-insensitively matched case returns.")
(is (match-i-case
("c" 0)
(otherwise 1))
1
"can return the value the otherwise form returns.")
(is-error (match-i-case
("c"))
'match-failed
"can raise the match-failed error with case-insensitively unmatched cases.")
(is (match-i-case
("bc" 0))
0
"can return the value the body form of the matched case returns even thogh eof.")))
(subtest "declaration of types"
(let ((str "LISP"))
(declare (type simple-string str))
(with-vector-parsing (str)
(is (current) #\L))))
(finalize)
| 9,719 | Common Lisp | .lisp | 277 | 27.415162 | 94 | 0.562845 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c4bc97e2e2f98cce245e5bb7c17fb02372e17acb365fd54af5be11cf28ad93c7 | 43,038 | [
425333
] |
43,040 | babel.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/babel-20200925-git/babel.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; babel.asd --- ASDF system definition for Babel.
;;;
;;; Copyright (C) 2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(defsystem babel
:description "Babel, a charset conversion library."
:author "Luis Oliveira <loliveira@common-lisp.net>"
:licence "MIT"
:depends-on (trivial-features alexandria)
:components
((:module src
:serial t
:components
((:file "packages")
(:file "encodings")
(:file "enc-ascii")
(:file "enc-ebcdic")
(:file "enc-ebcdic-int")
(:file "enc-iso-8859")
(:file "enc-unicode")
(:file "enc-cp437")
(:file "enc-cp1251")
(:file "enc-cp1252")
(:file "jpn-table")
(:file "enc-jpn")
(:file "enc-gbk")
(:file "enc-koi8")
(:file "external-format")
(:file "strings")
(:file "gbk-map")
(:file "sharp-backslash")))))
(defmethod perform ((o test-op) (c (eql (find-system :babel))))
(operate 'load-op :babel-tests)
(operate 'test-op :babel-tests))
(defmethod operation-done-p ((o test-op) (c (eql (find-system :babel))))
nil)
| 2,207 | Common Lisp | .asd | 57 | 35.649123 | 72 | 0.690265 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 348d45dac2499145b7727478fc0bc2f7dd7e03e5ac8cb600ff9f80a135f8b72c | 43,040 | [
467544
] |
43,043 | drakma.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/drakma.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; $Header: /usr/local/cvsrep/drakma/drakma.asd,v 1.49 2008/05/24 03:21:22 edi Exp $
;;; Copyright (c) 2006-2012, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :cl-user)
#+:lispworks
(unless (find-symbol "STREAM-WRITE-TIMEOUT" :stream)
(pushnew :lw-does-not-have-write-timeout *features*))
(defpackage :drakma-asd
(:use :cl :asdf))
(in-package :drakma-asd)
(defsystem :drakma
:description "Full-featured http/https client based on usocket"
:author "Dr. Edi Weitz"
:license "BSD"
:serial t
:version "2.0.9"
:components ((:file "packages")
(:file "specials")
(:file "conditions")
(:file "util")
(:file "read")
(:file "cookies")
(:file "encoding")
(:file "request"))
:depends-on (:puri
:cl-base64
:chunga
:flexi-streams
:cl-ppcre
#-:drakma-no-chipz :chipz
#-:lispworks :usocket
#-(or :lispworks7.1 (and :allegro (not :allegro-cl-express)) :mocl-ssl :drakma-no-ssl) :cl+ssl)
:perform (test-op (o s)
(asdf:load-system :drakma-test)
(asdf:perform 'asdf:test-op :drakma-test)))
| 2,610 | Common Lisp | .asd | 55 | 41.363636 | 110 | 0.662868 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 58a84814e5d314fc05714f6e13420c2ba4967d673b4685f5aec9c91b472b0086 | 43,043 | [
253159
] |
43,044 | drakma-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/drakma-test.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; Copyright (c) 2013, Anton Vodonosov. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(defsystem :drakma-test
:description "Test suite for drakma"
:author "Dr. Edi Weitz"
:license "BSD"
:serial t
:version "0.1"
:depends-on (:drakma :fiveam)
:pathname #P"test/"
:components ((:file "drakma-test"))
:perform (test-op (o s)
(uiop:symbol-call :fiveam '#:run! :drakma)))
| 1,739 | Common Lisp | .asd | 33 | 50.363636 | 71 | 0.731765 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 4689f9df2789f1bbd5cd577fb3d60a29212d6b1b7049672040f8e1b5a01e0fb1 | 43,044 | [
356760
] |
43,045 | trivial-garbage.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-garbage-20211230-git/trivial-garbage.asd | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-lisp; Base: 10; Package: ASDF -*-
;;;; The above modeline is required for Genera. Do not change.
;;;
;;; trivial-garbage.asd --- ASDF system definition for trivial-garbage.
;;;
;;; This software is placed in the public domain by Luis Oliveira
;;; <loliveira@common-lisp.net> and is provided with absolutely no
;;; warranty.
#-(or cmu scl sbcl allegro clisp openmcl corman lispworks ecl abcl clasp mezzano genera)
(error "Sorry, your Lisp is not supported by trivial-garbage.")
(defsystem trivial-garbage
:description "Portable finalizers, weak hash-tables and weak pointers."
:author "Luis Oliveira <loliveira@common-lisp.net>"
:in-order-to ((test-op (test-op "trivial-garbage/tests")))
:licence "Public Domain"
:components ((:file "trivial-garbage")))
(defsystem trivial-garbage/tests
:description "Unit tests for TRIVIAL-GARBAGE."
:depends-on (trivial-garbage rt)
:components ((:file "tests")))
(defmethod perform ((op test-op)
(sys (eql (find-system "trivial-garbage/tests"))))
(funcall (find-symbol (string '#:do-tests) '#:rtest)))
| 1,119 | Common Lisp | .asd | 23 | 45.826087 | 88 | 0.718864 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | b2a81520afab128a64903a59a97235ed3360a055d625b295b4c5a7fb030c1af3 | 43,045 | [
-1
] |
43,046 | alexandria.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/alexandria-20220707-git/alexandria.asd | (defsystem "alexandria"
:version "1.0.1"
:licence "Public Domain / 0-clause MIT"
:description "Alexandria is a collection of portable public domain utilities."
:author "Nikodemus Siivola and others."
:long-description
"Alexandria is a project and a library.
As a project Alexandria's goal is to reduce duplication of effort and improve
portability of Common Lisp code according to its own idiosyncratic and rather
conservative aesthetic.
As a library Alexandria is one of the means by which the project strives for
its goals.
Alexandria is a collection of portable public domain utilities that meet
the following constraints:
* Utilities, not extensions: Alexandria will not contain conceptual
extensions to Common Lisp, instead limiting itself to tools and utilities
that fit well within the framework of standard ANSI Common Lisp.
Test-frameworks, system definitions, logging facilities, serialization
layers, etc. are all outside the scope of Alexandria as a library, though
well within the scope of Alexandria as a project.
* Conservative: Alexandria limits itself to what project members consider
conservative utilities. Alexandria does not and will not include anaphoric
constructs, loop-like binding macros, etc.
Also, its exported symbols are being imported by many other packages
already, so each new export carries the danger of causing conflicts.
* Portable: Alexandria limits itself to portable parts of Common Lisp. Even
apparently conservative and useful functions remain outside the scope of
Alexandria if they cannot be implemented portably. Portability is here
defined as portable within a conforming implementation: implementation bugs
are not considered portability issues.
* Team player: Alexandria will not (initially, at least) subsume or provide
functionality for which good-quality special-purpose packages exist, like
split-sequence. Instead, third party packages such as that may be
\"blessed\"."
:components
((:static-file "LICENCE")
(:module "alexandria-1"
:components ((:static-file "tests.lisp")
(:file "package")
(:file "definitions" :depends-on ("package"))
(:file "binding" :depends-on ("package"))
(:file "strings" :depends-on ("package"))
(:file "conditions" :depends-on ("package"))
(:file "io" :depends-on ("package" "macros" "lists" "types"))
(:file "macros" :depends-on ("package" "strings" "symbols"))
(:file "hash-tables" :depends-on ("package" "macros"))
(:file "control-flow" :depends-on ("package" "definitions" "macros"))
(:file "symbols" :depends-on ("package"))
(:file "functions" :depends-on ("package" "symbols" "macros"))
(:file "lists" :depends-on ("package" "functions"))
(:file "types" :depends-on ("package" "symbols" "lists"))
(:file "arrays" :depends-on ("package" "types"))
(:file "sequences" :depends-on ("package" "lists" "types"))
(:file "numbers" :depends-on ("package" "sequences"))
(:file "features" :depends-on ("package" "control-flow"))))
(:module "alexandria-2"
:components ((:static-file "tests.lisp")
(:file "package")
(:file "arrays" :depends-on ("package"))
(:file "control-flow" :depends-on ("package"))
(:file "sequences" :depends-on ("package"))
(:file "lists" :depends-on ("package")))))
:in-order-to ((test-op (test-op "alexandria/tests"))))
(defsystem "alexandria/tests"
:licence "Public Domain / 0-clause MIT"
:description "Tests for Alexandria, which is a collection of portable public domain utilities."
:author "Nikodemus Siivola <nikodemus@sb-studio.net>, and others."
:depends-on (:alexandria #+sbcl :sb-rt #-sbcl :rt)
:components ((:file "alexandria-1/tests")
(:file "alexandria-2/tests"))
:perform (test-op (o c)
(let ((unexpected-failure-p nil))
(flet ((run-tests (&rest args)
(unless (apply (intern (string '#:run-tests) '#:alexandria/tests) args)
(setf unexpected-failure-p t))))
(run-tests :compiled nil)
(run-tests :compiled t))
(when unexpected-failure-p
(error "Unexpected test failure")))))
| 4,769 | Common Lisp | .asd | 79 | 48.164557 | 102 | 0.620461 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 430662260eb07fda95f3b066fd469fe0c2fb115aca19e56e85718edf8d2b8b64 | 43,046 | [
-1
] |
43,047 | cl-base64.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-base64-20201016-git/cl-base64.asd | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*-
;;;; *************************************************************************
;;;; FILE IDENTIFICATION
;;;;
;;;; Name: cl-base64.asd
;;;; Purpose: ASDF definition file for Cl-Base64
;;;; Programmer: Kevin M. Rosenberg
;;;; Date Started: Dec 2002
;;;; *************************************************************************
(in-package #:cl-user)
(defpackage #:cl-base64-system (:use #:asdf #:cl))
(in-package #:cl-base64-system)
(defsystem cl-base64
:name "cl-base64"
:author "Kevin M. Rosenberg based on initial code by Juri Pakaste"
:version "3.4"
:maintainer "Kevin M. Rosenberg <kmr@debian.org>"
:licence "BSD-style"
:description "Base64 encoding and decoding with URI support."
:components
((:file "package")
(:file "encode" :depends-on ("package"))
(:file "decode" :depends-on ("package")))
:in-order-to ((test-op (test-op "cl-base64/test"))))
(defsystem cl-base64/test
:depends-on (cl-base64 ptester kmrcl)
:components
((:file "tests"))
:perform (test-op (o s)
(or (funcall (intern (symbol-name '#:do-tests)
(find-package '#:cl-base64/test)))
(error "test-op failed"))))
| 1,294 | Common Lisp | .asd | 32 | 35.25 | 78 | 0.532963 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 79651ec81fcec69067d3076ccdcab0b257cb8cfa8d2c9a8ffd5aa3bdf0f110ba | 43,047 | [
-1
] |
43,048 | trivial-mimes.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-mimes-20221106-git/trivial-mimes.asd | #|
This file is a part of Trivial-Mimes
(c) 2014 Shirakumo http://tymoon.eu (shinmera@tymoon.eu)
Author: Nicolas Hafner <shinmera@tymoon.eu>
|#
(defsystem trivial-mimes
:name "Trivial-Mimes"
:version "1.1.0"
:license "zlib"
:author "Nicolas Hafner <shinmera@tymoon.eu>"
:maintainer "Nicolas Hafner <shinmera@tymoon.eu>"
:description "Tiny library to detect mime types in files."
:homepage "https://Shinmera.github.io/trivial-mimes/"
:bug-tracker "https://github.com/Shinmera/trivial-mimes/issues"
:source-control (:git "https://github.com/Shinmera/trivial-mimes.git")
:serial T
:components ((:file "mime-types"))
:depends-on ())
| 657 | Common Lisp | .asd | 18 | 33.944444 | 72 | 0.731975 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | d95914d39f9643c07c2451f3df3a84fe596b2a827d5d9da7883b41f884a04d46 | 43,048 | [
322929
] |
43,049 | trivial-features-tests.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-features-20211209-git/trivial-features-tests.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; trivial-features-tests.asd --- ASDF definition.
;;;
;;; Copyright (C) 2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(eval-when (:load-toplevel :execute)
;; We need to load trivial-features this way before the the
;; defsystem form is read for the corner case when someone loads
;; trivial-features-tests before trivial-features since the system
;; definition's got a #+windows reader conditional that is supplied
;; by trivial-features.
(oos 'load-op 'trivial-features))
(defsystem trivial-features-tests
:description "Unit tests for TRIVIAL-FEATURES."
:author "Luis Oliveira <loliveira@common-lisp.net>"
:licence "MIT"
:defsystem-depends-on (cffi-grovel)
:depends-on (trivial-features rt cffi alexandria)
:components
((:module tests
:serial t
:components
((:file "package")
#-windows (:cffi-grovel-file "utsname")
#+windows (:file "sysinfo")
(:file "tests")))))
(defmethod perform ((o test-op) (c (eql (find-system 'trivial-features-tests))))
(let ((*package* (find-package 'trivial-features-tests)))
(funcall (find-symbol (symbol-name '#:do-tests)))))
| 2,276 | Common Lisp | .asd | 49 | 44.183673 | 80 | 0.732914 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | be92628bf193ee9ace7e51a921e52d83801245af577406d87bef4473dfa43951 | 43,049 | [
83916
] |
43,050 | trivial-features.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-features-20211209-git/trivial-features.asd | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Package: ASDF; Base: 10; -*-
;;;; The above modeline is required for Genera. Do not change.
;;;
;;; trivial-features.asd --- ASDF system definition.
;;;
;;; Copyright (C) 2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
#-(or sbcl clisp allegro openmcl mcl mkcl lispworks ecl cmu scl cormanlisp abcl xcl mocl clasp mezzano genera)
(error "Sorry, your Lisp is not supported. Patches welcome.")
(defsystem trivial-features
:description "Ensures consistent *FEATURES* across multiple CLs."
:author "Luis Oliveira <loliveira@common-lisp.net>"
:licence "MIT"
:components
((:module src
:serial t
:components
(#+allegro (:file "tf-allegro")
#+clisp (:file "tf-clisp")
#+cmu (:file "tf-cmucl")
#+cormanlisp (:file "tf-cormanlisp")
#+ecl (:file "tf-ecl")
#+genera (:file "tf-genera")
#+lispworks (:file "tf-lispworks")
#+openmcl (:file "tf-openmcl")
#+mcl (:file "tf-mcl")
#+mkcl (:file "tf-mkcl")
#+sbcl (:file "tf-sbcl")
#+scl (:file "tf-scl")
#+abcl (:file "tf-abcl")
#+xcl (:file "tf-xcl")
#+mocl (:file "tf-mocl")
#+clasp (:file "tf-clasp")
#+mezzano (:file "tf-mezzano")
))))
#-(or genera mezzano)
(defmethod perform ((o test-op) (c (eql (find-system 'trivial-features))))
(operate 'load-op 'trivial-features-tests)
(operate 'test-op 'trivial-features-tests))
| 2,604 | Common Lisp | .asd | 58 | 41.931034 | 110 | 0.673221 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 904989ceb7e5a3d8d32f6a6cf2d3205f903778ebc83429e4d49917ff526585b9 | 43,050 | [
-1
] |
43,051 | usocket-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/usocket-test.asd | ;;;; -*- Mode: Lisp -*-
;;;; See the LICENSE file for licensing information.
(defsystem usocket-test
:name "usocket test"
:author "Erik Enge"
:maintainer "Chun Tian (binghe)"
:version (:read-file-form "version.sexp")
:licence "MIT"
:description "Tests for usocket"
:depends-on (:usocket-server :rt)
:components ((:module "tests"
:serial t
:components ((:file "package")
(:file "test-usocket")
(:file "test-condition")
(:file "test-datagram")
(:file "test-timeout")
(:file "wait-for-input"))))
:perform (test-op (o c) (symbol-call :usocket-test :do-tests)))
| 786 | Common Lisp | .asd | 19 | 28.315789 | 67 | 0.499346 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | bca7645f290b8983bc35ad8e88621bbf0ea0bb194f9e06c1ccedb0b1d7427e9a | 43,051 | [
-1
] |
43,052 | usocket.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/usocket.asd | ;;;; -*- Mode: LISP; Base: 10; Syntax: ANSI-Common-lisp; -*-
;;;;
;;;; See the LICENSE file for licensing information.
(in-package :asdf)
;;; NOTE: the key "art" here is, no need to recompile any file when switching
;;; between a native backend and IOlib backend. -- Chun Tian (binghe)
#+sample
(pushnew :usocket-iolib *features*)
(defsystem usocket
:name "usocket (client, with server symbols)"
:author "Erik Enge & Erik Huelsmann"
:maintainer "Chun Tian (binghe) & Hans Huebner"
:version (:read-file-form "version.sexp")
:licence "MIT"
:description "Universal socket library for Common Lisp"
:depends-on (:split-sequence
(:feature (:and (:or :sbcl :ecl)
(:not :usocket-iolib))
:sb-bsd-sockets)
(:feature :usocket-iolib
:iolib))
:components ((:file "package")
(:module "vendor" :depends-on ("package")
:if-feature :mcl
:components ((:file "kqueue")
(:file "OpenTransportUDP")))
(:file "usocket" :depends-on ("vendor"))
(:file "condition" :depends-on ("usocket"))
(:module "backend"
:depends-on ("condition")
:components ((:file "iolib"
:if-feature :usocket-iolib)
(:file "abcl"
:if-feature (:and :abcl
(:not :usocket-iolib)))
(:file "allegro"
:if-feature (:and (:or :allegro :cormanlisp)
(:not :usocket-iolib)))
(:file "clisp"
:if-feature (:and :clisp
(:not :usocket-iolib)))
(:file "openmcl"
:if-feature (:and (:or :openmcl :clozure)
(:not :usocket-iolib)))
(:file "clozure"
:if-feature (:and :clozure
(:not :usocket-iolib))
:depends-on ("openmcl"))
(:file "cmucl"
:if-feature (:and :cmu
(:not :usocket-iolib)))
(:file "sbcl"
:if-feature (:and (:or :sbcl :ecl :clasp)
(:not :usocket-iolib)))
(:file "ecl"
:if-feature (:and :ecl
(:not :usocket-iolib))
:depends-on ("sbcl"))
(:file "clasp"
:if-feature (:and :clasp
(:not :usocket-iolib))
:depends-on ("sbcl"))
(:file "lispworks"
:if-feature (:and :lispworks
(:not :usocket-iolib)))
(:file "mcl"
:if-feature (:and :mcl
(:not :usocket-iolib)))
(:file "mocl"
:if-feature (:and :mocl
(:not :usocket-iolib)))
(:file "scl"
:if-feature (:and :scl
(:not :usocket-iolib)))
(:file "genera"
:if-feature (:and :genera
(:not :usocket-iolib)))
(:file "mezzano"
:if-feature (:and :mezzano))))
(:file "option"
:if-feature (:not :usocket-iolib)
:depends-on ("backend")))
:in-order-to ((test-op (test-op :usocket-test))))
| 4,394 | Common Lisp | .asd | 83 | 26.156627 | 77 | 0.349199 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e31d504d94f62927dae649ca5babf0249353e9c3278b2a8aba33528d5c1d31fb | 43,052 | [
42860
] |
43,053 | usocket-server.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/usocket-server.asd | ;;;; -*- Mode: Lisp -*-
;;;;
;;;; See the LICENSE file for licensing information.
(in-package :asdf)
(defsystem usocket-server
:name "usocket (server)"
:author "Chun Tian (binghe)"
:version (:read-file-form "version.sexp")
:licence "MIT"
:description "Universal socket library for Common Lisp (server side)"
:depends-on (:usocket :bordeaux-threads)
:components ((:file "server")))
| 411 | Common Lisp | .asd | 12 | 30.75 | 73 | 0.672544 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 32194eed9470a1b6af200bd13dfaf2db23feaab4d243353baa51ee8395f2108c | 43,053 | [
189606
] |
43,054 | bordeaux-threads.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/bordeaux-threads-v0.8.8/bordeaux-threads.asd | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-lisp; Base: 10; Package: ASDF -*-
;;;; The above modeline is required for Genera. Do not change.
#|
Copyright 2006,2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
#.(unless (or #+asdf3.1 (version<= "3.1" (asdf-version)))
(error "You need ASDF >= 3.1 to load this system correctly."))
(eval-when (:compile-toplevel :load-toplevel :execute)
#+(or armedbear
(and allegro multiprocessing)
(and clasp threads)
(and clisp mt)
(and openmcl openmcl-native-threads)
(and cmu mp)
corman
(and ecl threads)
genera
mezzano
mkcl
lispworks
(and digitool ccl-5.1)
(and sbcl sb-thread)
scl)
(pushnew :thread-support *features*))
(defsystem :bordeaux-threads
:author "Greg Pfeil <greg@technomadic.org>"
:licence "MIT"
:description "Bordeaux Threads makes writing portable multi-threaded apps simple."
:version (:read-file-form "version.sexp")
:depends-on (:alexandria
#+(and allegro (version>= 9)) (:require "smputil")
#+(and allegro (not (version>= 9))) (:require "process")
#+corman (:require "threads"))
:components ((:static-file "version.sexp")
(:module "src"
:serial t
:components
((:file "pkgdcl")
(:file "bordeaux-threads")
(:file #+(and thread-support armedbear) "impl-abcl"
#+(and thread-support allegro) "impl-allegro"
#+(and thread-support clasp) "impl-clasp"
#+(and thread-support clisp) "impl-clisp"
#+(and thread-support openmcl) "impl-clozure"
#+(and thread-support cmu) "impl-cmucl"
#+(and thread-support corman) "impl-corman"
#+(and thread-support ecl) "impl-ecl"
#+(and thread-support genera) "impl-genera"
#+(and thread-support mezzano) "impl-mezzano"
#+(and thread-support mkcl) "impl-mkcl"
#+(and thread-support lispworks) "impl-lispworks"
#+(and thread-support digitool) "impl-mcl"
#+(and thread-support sbcl) "impl-sbcl"
#+(and thread-support scl) "impl-scl"
#-thread-support "impl-null")
#+(and thread-support lispworks (or lispworks4 lispworks5))
(:file "impl-lispworks-condition-variables")
#+(and thread-support digitool)
(:file "condition-variables")
(:file "default-implementations"))))
:in-order-to ((test-op (test-op :bordeaux-threads/test))))
(defsystem :bordeaux-threads/test
:author "Greg Pfeil <greg@technomadic.org>"
:description "Bordeaux Threads test suite."
:licence "MIT"
:version (:read-file-form "version.sexp")
:depends-on (:bordeaux-threads :fiveam)
:components ((:module "test"
:components ((:file "bordeaux-threads-test"))))
:perform (test-op (o c) (symbol-call :5am :run! :bordeaux-threads)))
| 3,343 | Common Lisp | .asd | 71 | 35.422535 | 84 | 0.548377 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | d58d7d96fb20ccae0a4e7b27fd85952689c14560ed5ffff75e0ae5de575c5620 | 43,054 | [
-1
] |
43,055 | dexador.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/dexador-20221106-git/dexador.asd | #|
This file is a part of dexador project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
#|
Author: Eitaro Fukamachi (e.arrows@gmail.com)
|#
(defsystem "dexador"
:version "0.9.15"
:author "Eitaro Fukamachi"
:license "MIT"
:defsystem-depends-on ("trivial-features")
:depends-on ("fast-http"
"quri"
"fast-io"
"babel"
"trivial-gray-streams"
"trivial-garbage"
"chunga"
"cl-ppcre"
"cl-cookie"
"trivial-mimes"
"chipz"
"cl-base64"
"usocket"
(:feature :windows "winhttp")
(:feature :windows "flexi-streams")
(:feature (:and (:not :windows) (:not :dexador-no-ssl)) "cl+ssl")
"bordeaux-threads"
"alexandria"
(:version "uiop" "3.1.1"))
:components ((:module "src"
:components
((:file "dexador" :depends-on ("backend" "error"))
(:file "encoding")
(:file "connection-cache")
(:file "decoding-stream")
(:file "keep-alive-stream")
(:file "body" :depends-on ("encoding" "decoding-stream" "util"))
(:file "error")
(:file "util")
(:module "backend"
:depends-on ("encoding" "connection-cache" "decoding-stream" "keep-alive-stream" "body" "error" "util")
:components
((:file "usocket")
(:file "winhttp" :if-feature :windows))))))
:description "Yet another HTTP client for Common Lisp"
:in-order-to ((test-op (test-op "dexador-test"))))
| 1,765 | Common Lisp | .asd | 48 | 24.625 | 121 | 0.492711 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 01e3a6a1d30af441c1182be4bd882127f9b1cf2312f0ef9fc1c1a547871baba7 | 43,055 | [
-1
] |
43,056 | dexador-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/dexador-20221106-git/dexador-test.asd | #|
This file is a part of dexador project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
(defsystem "dexador-test"
:author "Eitaro Fukamachi"
:license "MIT"
:depends-on ("dexador"
"rove"
"lack-request"
"clack-test"
"babel"
"cl-cookie")
:components ((:module "t"
:components
((:file "dexador"))))
:perform (test-op (op c) (symbol-call '#:rove '#:run c)))
| 490 | Common Lisp | .asd | 17 | 20.647059 | 59 | 0.53178 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 866b00526a52623fd1bb994428bbb6107263752f7eafa549a20ac1ca7e5cbd14 | 43,056 | [
-1
] |
43,057 | zpng.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/zpng-1.2.2/zpng.asd | ;;;
;;; Copyright (c) 2007 Zachary Beane, All Rights Reserved
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;
(asdf:defsystem #:zpng
:depends-on (#:salza2)
:version "1.2.2"
:description "Create PNG files"
:license "BSD"
:components ((:file "package")
(:file "specials"
:depends-on ("package"))
(:file "utils"
:depends-on ("package"))
(:file "chunk"
:depends-on ("utils"))
(:file "conditions"
:depends-on ("package"))
(:file "png"
:depends-on ("specials"
"chunk"
"conditions"
"utils"))))
| 2,040 | Common Lisp | .asd | 46 | 36.804348 | 70 | 0.629704 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 51b8a249877de1e9f6a9b9253d466999fa402311462fe0b43f8fc704be4159f0 | 43,057 | [
395210
] |
43,058 | quri.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/quri-20221106-git/quri.asd | (defsystem "quri"
:version "0.6.0"
:author "Eitaro Fukamachi"
:maintainer "Pierre Neidhardt"
:license "BSD 3-Clause"
:depends-on ("babel"
"alexandria"
"split-sequence"
"cl-utilities"
#+sbcl "sb-cltl2")
:components ((:module "src"
:components
((:file "quri" :depends-on ("uri" "uri-classes" "domain" "parser" "decode" "encode" "error"))
(:file "uri" :depends-on ("port"))
(:module "uri-classes"
:pathname "uri"
:depends-on ("uri" "port" "encode" "decode")
:components
((:file "ftp")
(:file "http")
(:file "ldap")
(:file "file")))
(:file "domain" :depends-on ("uri" "etld"))
(:file "etld")
(:file "parser" :depends-on ("error" "util"))
(:file "decode" :depends-on ("error" "util"))
(:file "encode" :depends-on ("error" "util"))
(:file "port")
(:file "util")
(:file "error"))))
:description "Yet another URI library for Common Lisp"
:in-order-to ((test-op (test-op "quri-test"))))
| 1,285 | Common Lisp | .asd | 32 | 26.4375 | 109 | 0.450918 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | f130a0fc26f78064f04b2e6c1e61c9f793e3a1094eb6c52071841f58ed8f0fd4 | 43,058 | [
-1
] |
43,059 | quri-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/quri-20221106-git/quri-test.asd | #|
This file is a part of quri project.
Copyright (c) 2014 Eitaro Fukamachi (e.arrows@gmail.com)
|#
(defsystem quri-test
:author "Eitaro Fukamachi"
:license "BSD 3-Clause"
:depends-on (:quri
:prove)
:components ((:module "t"
:components
((:test-file "quri")
(:test-file "parser")
(:test-file "decode")
(:test-file "encode")
(:test-file "domain")
(:test-file "etld")
(:file "benchmark"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove-asdf) c)
(asdf:clear-system c)))
| 749 | Common Lisp | .asd | 22 | 23.636364 | 80 | 0.511724 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | db05f12cf73e7a90a43ad7761bea8ff96a0e734dcda8dab7f6a9356b1441a763 | 43,059 | [
-1
] |
43,060 | split-sequence.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/split-sequence-v2.0.1/split-sequence.asd | ;;; -*- Lisp -*-
#.(unless (or #+asdf3.1 (version<= "3.1" (asdf-version)))
(error "You need ASDF >= 3.1 to load this system correctly."))
(defsystem :split-sequence
:author "Arthur Lemmens <alemmens@xs4all.nl>"
:maintainer "Sharp Lispers <sharplispers@googlegroups.com>"
:description "Splits a sequence into a list of subsequences
delimited by objects satisfying a test."
:license "MIT"
:version (:read-file-form "version.sexp")
:components ((:static-file "version.sexp")
(:file "package")
(:file "vector")
(:file "list")
(:file "extended-sequence" :if-feature (:or :sbcl :abcl))
(:file "api")
(:file "documentation"))
:in-order-to ((test-op (test-op :split-sequence/tests))))
(defsystem :split-sequence/tests
:author "Arthur Lemmens <alemmens@xs4all.nl>"
:maintainer "Sharp Lispers <sharplispers@googlegroups.com>"
:description "Split-Sequence test suite"
:license "MIT"
:depends-on (:split-sequence :fiveam)
:components ((:file "tests"))
:perform (test-op (o c) (symbol-call :5am :run! :split-sequence)))
| 1,134 | Common Lisp | .asd | 26 | 37.730769 | 72 | 0.647964 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 437db3c0af6748b85014b84355eb2d989d24481f75fb14a13c28aa2abe8ceffa | 43,060 | [
100731
] |
43,061 | smart-buffer.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/smart-buffer-20211020-git/smart-buffer.asd | #|
This file is a part of smart-buffer project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
#|
Author: Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage smart-buffer-asd
(:use :cl :asdf))
(in-package :smart-buffer-asd)
(defsystem smart-buffer
:version "0.1"
:author "Eitaro Fukamachi"
:license "BSD 3-Clause"
:depends-on (:xsubseq
:flexi-streams
:uiop)
:components ((:module "src"
:components
((:file "smart-buffer"))))
:description "Smart octets buffer"
:long-description
#.(with-open-file (stream (merge-pathnames
#p"README.markdown"
(or *load-pathname* *compile-file-pathname*))
:if-does-not-exist nil
:direction :input)
(when stream
(let ((seq (make-array (file-length stream)
:element-type 'character
:fill-pointer t)))
(setf (fill-pointer seq) (read-sequence seq stream))
seq))))
| 1,126 | Common Lisp | .asd | 34 | 23.323529 | 74 | 0.549128 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 9f1883d78696eef5c7f815596d70b64710b2c67df3a73ef62912b6ed1378009d | 43,061 | [
298555
] |
43,062 | smart-buffer-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/smart-buffer-20211020-git/smart-buffer-test.asd | (in-package :cl-user)
(defpackage smart-buffer-test-asd
(:use :cl :asdf))
(in-package :smart-buffer-test-asd)
(defsystem smart-buffer-test
:depends-on (:smart-buffer
:babel
:prove)
:components ((:module "t"
:components
((:test-file "smart-buffer"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove.asdf) c)
(asdf:clear-system c)))
| 518 | Common Lisp | .asd | 15 | 25.933333 | 80 | 0.568862 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | f6c4be680fe276ad4696125644845ff53d937f51842d1adfb60ea8e3a8f2d432 | 43,062 | [
352388
] |
43,064 | trivial-gray-streams-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-gray-streams-20210124-git/trivial-gray-streams-test.asd | ;;;; -*- Mode: LISP; Base: 10; Syntax: ANSI-Common-lisp; -*-
(defsystem :trivial-gray-streams-test
:version "2.0"
:depends-on (:trivial-gray-streams)
:pathname #P"test/"
:serial t
:components ((:file "package")
(:file "test-framework")
(:file "test")))
| 294 | Common Lisp | .asd | 9 | 27.111111 | 60 | 0.588028 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 0abd7d594a91b7fb683094ac709460ccf7d2c6e04a30f028ed4f72f5853d2bb6 | 43,064 | [
53916
] |
43,065 | trivial-gray-streams.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-gray-streams-20210124-git/trivial-gray-streams.asd | ;;;; -*- Mode: LISP; Base: 10; Syntax: ANSI-Common-lisp; -*-
(defsystem :trivial-gray-streams
:description "Compatibility layer for Gray Streams (see http://www.cliki.net/Gray%20streams)."
:license "MIT"
:author "David Lichteblau"
:maintainer "Anton Vodonosov <avodonosov@yandex.ru>"
:version "2.0"
:serial t
:components ((:file "package") (:file "streams")))
| 375 | Common Lisp | .asd | 9 | 39 | 96 | 0.70137 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | dc77b96f61c15b6282779536876d5c67b046b329384669e0f435d900d0af1b4a | 43,065 | [
34713
] |
43,066 | chipz.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/chipz-20220220-git/chipz.asd | ; -*- mode: lisp -*-
(cl:defpackage :chipz-system
(:use :cl :asdf)
(:export #:gray-streams))
(cl:in-package :chipz-system)
(defclass txt-file (doc-file) ((type :initform "txt")))
(defclass css-file (doc-file) ((type :initform "css")))
(eval-when (:compile-toplevel :load-toplevel :execute)
#+(or sbcl lispworks openmcl cmu allegro clisp ecl genera clasp)
(pushnew 'chipz-system:gray-streams cl:*features*))
(asdf:defsystem :chipz
:version "0.8"
:author "Nathan Froyd <froydnj@gmail.com>"
:maintainer "Nathan Froyd <froydnj@gmail.com>"
:description "A library for decompressing deflate, zlib, and gzip data"
:license "BSD style"
:components ((:static-file "NEWS")
(:static-file "LICENSE")
(:static-file "TODO")
(:file "package")
(:module "doc"
:components
((:html-file "index")
(:txt-file "chipz-doc")
(:css-file "style")))
(:file "constants" :depends-on ("package"))
(:file "types-and-tables" :depends-on ("constants"))
(:file "crc32" :depends-on ("types-and-tables"))
(:file "adler32" :depends-on ("types-and-tables"))
(:file "conditions" :depends-on ("package"))
(:file "dstate" :depends-on ("package"))
(:file "inflate-state" :depends-on ("dstate" "crc32" "adler32"))
(:file "gzip" :depends-on ("inflate-state" "conditions"))
(:file "zlib" :depends-on ("inflate-state" "conditions"))
(:file "inflate" :depends-on ("inflate-state"
"gzip" "zlib"
"conditions"))
(:file "bzip2" :depends-on ("dstate" "constants"))
(:file "decompress" :depends-on ("inflate-state"
"inflate" "bzip2"))
#+chipz-system:gray-streams
(:file "stream" :depends-on ("inflate-state" "inflate"))
#-chipz-system:gray-streams
(:file "stream-fallback" :depends-on ("package"))))
| 2,207 | Common Lisp | .asd | 44 | 36.431818 | 79 | 0.523854 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 0c62e388a986a8790a544d42977e1a8a9d29d41be26c37b2970bc25378e17812 | 43,066 | [
336904
] |
43,067 | salza2.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/salza2-2.1/salza2.asd | ;;;
;;; Copyright (c) 2007 Zachary Beane, All Rights Reserved
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;
(asdf:defsystem #:salza2
:author "Zachary Beane <xach@xach.com>"
:license "BSD"
:version "2.1"
:description "Create compressed data in the ZLIB, DEFLATE, or GZIP
data formats"
:depends-on ("trivial-gray-streams")
:in-order-to ((asdf:test-op (asdf:test-op "salza2/test")))
:components ((:file "package")
(:file "reset"
:depends-on ("package"))
(:file "specials"
:depends-on ("package"))
(:file "types"
:depends-on ("package"
"specials"))
(:file "checksum"
:depends-on ("package"
"reset"))
(:file "adler32"
:depends-on ("checksum"
"types"))
(:file "crc32"
:depends-on ("checksum"
"types"))
(:file "chains"
:depends-on ("package"
"specials"))
(:file "bitstream"
:depends-on ("package"
"specials"
"reset"))
(:file "matches"
:depends-on ("package"
"types"))
(:file "compress"
:depends-on ("types"
"matches"))
(:file "huffman"
:depends-on ("package"))
(:file "closures"
:depends-on ("huffman"
"bitstream"))
(:file "compressor"
:depends-on ("package"
"closures"
"utilities"
"specials"
"bitstream"
"reset"))
(:file "utilities"
:depends-on ("package"))
(:file "zlib"
:depends-on ("package"
"adler32"
"reset"
"compressor"))
(:file "gzip"
:depends-on ("package"
"crc32"
"reset"
"compressor"))
(:file "user"
:depends-on ("package"
"compressor"
"zlib"
"gzip"))
(:file "stream"
:depends-on ("package"))))
(asdf:defsystem #:salza2/test
:author "Zachary Beane <xach@xach.com>"
:license "BSD"
:version "2.1"
:description "Tests for Salza2 system"
:depends-on ("salza2" "parachute" "flexi-streams" "chipz")
:perform (asdf:test-op (op c)
(unless (eql :passed
(uiop:symbol-call
:parachute :status
(uiop:symbol-call :parachute :test :salza2-test)))
(error "Tests failed")))
:pathname "test/"
:components ((:file "package")
(:file "stream" :depends-on ("package"))))
| 4,830 | Common Lisp | .asd | 111 | 26.990991 | 89 | 0.463854 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e349b1f3620c1075870ffd8f6ff28dc2d35f3342245115a5059de5986586c524 | 43,067 | [
-1
] |
43,068 | fast-io-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/fast-io-20221106-git/fast-io-test.asd | (cl:eval-when (:load-toplevel :execute)
(asdf:load-system :fiveam)
(asdf:load-system :checkl))
(defsystem :fast-io-test
:description "Tests for fast-io"
:depends-on (:fast-io :checkl)
:pathname "t"
:serial t
:components
((:file "package")
(:file "benchmark-defs")
(checkl:tests "basic")
(checkl:tests "gray")
(checkl:test-values "test-values"
:package :fast-io.test)))
(checkl:define-test-op :fast-io :fast-io-test)
(checkl:define-test-op :fast-io-test)
| 511 | Common Lisp | .asd | 17 | 25.705882 | 48 | 0.663934 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | f3b1eba2ac0ecdbf5531b412371a7755d310f04fb2eab82dcc416a95b2568f04 | 43,068 | [
228526
] |
43,069 | fast-io.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/fast-io-20221106-git/fast-io.asd | (eval-when (:compile-toplevel :load-toplevel :execute)
(pushnew :fast-io *features*))
#+(or sbcl ccl cmucl ecl lispworks allegro)
(eval-when (:compile-toplevel :load-toplevel :execute)
(pushnew :fast-io-sv *features*))
(defsystem :fast-io
:description "Alternative I/O mechanism to a stream or vector"
:author "Ryan Pavlik"
:license "MIT"
:version "1.0"
:depends-on (:alexandria :trivial-gray-streams
#+fast-io-sv
:static-vectors)
:pathname "src"
:serial t
:components
((:file "package")
(:file "types")
(:file "io")
(:file "gray")))
| 600 | Common Lisp | .asd | 20 | 25.7 | 64 | 0.662609 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | fd25a7dfae64e5854232f1f86df0e6658aec981ca314c4653e6cbdd73f35ba76 | 43,069 | [
223682
] |
43,070 | flexi-streams.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/flexi-streams-20220220-git/flexi-streams.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; $Header: /usr/local/cvsrep/flexi-streams/flexi-streams.asd,v 1.79 2008/08/26 10:59:22 edi Exp $
;;; Copyright (c) 2005-2008, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :cl-user)
(defpackage :flexi-streams-system
(:use :asdf :cl))
(in-package :flexi-streams-system)
;;; Maybe it can be made work for some encodings
(when (<= char-code-limit 65533)
(error "flexi-streams doesn't work on implementations with CHAR-CODE-LIMIT (~a) less than 65533"
char-code-limit))
(defsystem :flexi-streams
:version "1.0.19"
:serial t
:description "Flexible bivalent streams for Common Lisp"
:license "BSD-2-Clause"
:components ((:file "packages")
(:file "mapping")
(:file "ascii")
(:file "koi8-r")
(:file "mac")
(:file "iso-8859")
(:file "enc-cn-tbl")
(:file "code-pages")
(:file "specials")
(:file "util")
(:file "conditions")
(:file "external-format")
(:file "length")
(:file "encode")
(:file "decode")
(:file "in-memory")
(:file "stream")
#+:lispworks (:file "lw-char-stream")
(:file "output")
(:file "input")
(:file "io")
(:file "strings"))
:depends-on (:trivial-gray-streams))
(defmethod perform ((o test-op) (c (eql (find-system 'flexi-streams))))
(operate 'load-op 'flexi-streams-test)
(funcall (intern (symbol-name :run-all-tests)
(find-package :flexi-streams-test))))
| 2,998 | Common Lisp | .asd | 63 | 40.650794 | 99 | 0.642613 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c8b3f9e8b35a2727c7a6b18868f1c8e0515d05fe7278a583a2d8a5c3956acfaa | 43,070 | [
-1
] |
43,071 | flexi-streams-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/flexi-streams-20220220-git/flexi-streams-test.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; Copyright (c) 2005-2008, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :cl-user)
(defpackage :flexi-streams-system
(:use :asdf :cl))
(in-package :flexi-streams-system)
(defsystem :flexi-streams-test
:components ((:module "test"
:serial t
:components ((:file "packages")
(:file "test"))))
:depends-on (:flexi-streams))
| 1,780 | Common Lisp | .asd | 32 | 51.5 | 71 | 0.711328 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 7f84ddb7593295b1365f36ac2651582269119d5ddf03217af13c5bdfa6c8eaca | 43,071 | [
-1
] |
43,072 | zpb-ttf.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/zpb-ttf-release-1.0.4/zpb-ttf.asd | ;; $Id: zpb-ttf.asd,v 1.5 2006/03/24 20:47:27 xach Exp $
(defpackage #:zpb-ttf-system
(:use #:cl #:asdf))
(in-package #:zpb-ttf-system)
(defsystem #:zpb-ttf
:version "1.0.3"
:author "Zach Beane <xach@xach.com>"
:description "Access TrueType font metrics and outlines from Common Lisp"
:license "BSD"
:components ((:file "package")
(:file "util"
:depends-on ("package"))
(:file "conditions"
:depends-on ("package"))
(:file "bounding-box"
:depends-on ("package"))
(:file "font-loader"
:depends-on ("package"
"util"
"bounding-box"))
(:file "maxp"
:depends-on ("package"
"util"
"font-loader"))
(:file "head"
:depends-on ("package"
"util"
"conditions"
"font-loader"))
(:file "kern"
:depends-on ("package"
"util"
"conditions"
"font-loader"))
(:file "loca"
:depends-on ("package"
"util"
"font-loader"))
(:file "name"
:depends-on ("package"
"util"
"conditions"
"font-loader"))
(:file "cmap"
:depends-on ("package"
"util"
"name"
"font-loader"))
(:file "post"
:depends-on ("package"
"util"
"conditions"
"font-loader"))
(:file "hhea"
:depends-on ("package"
"util"
"font-loader"))
(:file "hmtx"
:depends-on ("package"
"util"
"font-loader"
"hhea"))
(:file "glyf"
:depends-on ("package"
"util"
"loca"
"font-loader"))
(:file "glyph"
:depends-on ("package"
"util"
"font-loader"
"bounding-box"
"glyf"
"kern"
"loca"))
(:file "font-loader-interface"
:depends-on ("package"
"util"
"conditions"
"font-loader"
"maxp"
"head"
"kern"
"loca"
"name"
"cmap"
"post"
"hhea"
"hmtx"))))
| 3,709 | Common Lisp | .asd | 89 | 15.348315 | 75 | 0.263624 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 606006ad445353a07dc2d610ee24cef8a8a34bea45d97245e5186a7636fbdd1d | 43,072 | [
-1
] |
43,073 | static-vectors.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/static-vectors-v1.8.9/static-vectors.asd | ;;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
#.(unless (or #+asdf3.1 (version<= "3.1" (asdf-version)))
(error "You need ASDF >= 3.1 to load this system correctly."))
(defsystem :static-vectors
:description "Create vectors allocated in static memory."
:author "Stelian Ionescu <sionescu@cddr.org>"
:licence "MIT"
:version (:read-file-form "version.sexp")
:defsystem-depends-on (#+(or abcl allegro clasp cmu ecl sbcl) :cffi-grovel)
:depends-on (:alexandria :cffi)
:pathname "src/"
:components ((:file "pkgdcl")
(:file "constantp" :depends-on ("pkgdcl"))
#+(or abcl allegro clasp cmu ecl)
(:cffi-grovel-file "ffi-types" :depends-on ("pkgdcl"))
(:file "impl"
:depends-on ("pkgdcl" "constantp"
#+(or abcl allegro cmu ecl) "ffi-types")
:pathname #+abcl "impl-abcl"
#+allegro "impl-allegro"
#+ccl "impl-clozure"
#+clasp "impl-clasp"
#+cmu "impl-cmucl"
#+ecl "impl-ecl"
#+lispworks "impl-lispworks"
#+sbcl "impl-sbcl"
#-(or abcl allegro ccl clasp cmu ecl lispworks sbcl)
#.(error "static-vectors does not support this Common Lisp implementation!"))
(:file "constructor" :depends-on ("pkgdcl" "constantp" "impl"))
(:file "cffi-type-translator" :depends-on ("pkgdcl" "impl")))
:in-order-to ((test-op (test-op :static-vectors/test))))
(defsystem :static-vectors/test
:description "Static-vectors test suite."
:author "Stelian Ionescu <sionescu@cddr.org>"
:licence "MIT"
:version (:read-file-form "version.sexp")
:depends-on (:static-vectors :fiveam)
:pathname "tests/"
:components ((:file "static-vectors-tests"))
:perform (test-op (o c) (symbol-call :5am :run! :static-vectors)))
| 2,106 | Common Lisp | .asd | 40 | 39.15 | 111 | 0.532719 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e2d8043c0e91a060828eebc3e53171e5c76b6fe710276c85e287d847c07a4924 | 43,073 | [
-1
] |
43,074 | cl+ssl.test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl+ssl-20221106-git/cl+ssl.test.asd | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; indent-tabs-mode: nil; coding: utf-8; show-trailing-whitespace: t -*-
;;;
;;; Copyright (C) 2015 Ilya Khaprov <ilya.khaprov@publitechs.com>
;;;
;;; See LICENSE for details.
(defsystem :cl+ssl.test
:version "0.1"
:description "CL+SSL test suite"
:maintainer "Ilya Khaprov <ilya.khaprov@publitechs.com>"
:author "Ilya Khaprov <ilya.khaprov@publitechs.com>"
:licence "MIT"
:depends-on (:cl+ssl
:fiveam
:usocket
:trivial-sockets ; for client-server.lisp
:bordeaux-threads ; for client-server.lisp
(:feature (:or :sbcl :ccl) :cl-coveralls))
:serial t
:components ((:module "test"
:serial t
:components
((:file "package")
(:file "dummy")
(:file "version")
(:file "sni")
(:file "cert-utilities")
(:file "validity-dates")
(:file "fingerprint")
(:file "verify-hostname")
(:file "badssl-com")
(:file "bio")
(:file "alpn")
(:file "client-server")))))
| 1,209 | Common Lisp | .asd | 33 | 25.727273 | 111 | 0.514894 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c2b1baa89fb98ab84213b5a4fc04332621eedba6f048ae563c78633aa23c3a8f | 43,074 | [
-1
] |
43,075 | cl+ssl.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl+ssl-20221106-git/cl+ssl.asd | ;;;; -*- Mode: LISP; Syntax: COMMON-LISP; indent-tabs-mode: nil; coding: utf-8; show-trailing-whitespace: t -*-
;;;
;;; Copyright (C) 2001, 2003 Eric Marsden
;;; Copyright (C) 2005 David Lichteblau
;;; Copyright (C) 2007 Pixel // pinterface
;;; "the conditions and ENSURE-SSL-FUNCALL are by Jochen Schmidt."
;;;
;;; See LICENSE for details.
(defsystem :cl+ssl
:description "Common Lisp interface to OpenSSL."
:license "MIT"
:author "Eric Marsden, Jochen Schmidt, David Lichteblau"
:depends-on (:cl+ssl/config
:cffi
:trivial-gray-streams
:flexi-streams
:bordeaux-threads
:trivial-garbage
:uiop
:usocket
:alexandria
:trivial-features
(:feature :sbcl :sb-posix)
(:feature (:and :sbcl :win32) :sb-bsd-sockets))
:serial t
:components ((:module "src"
:serial t
:components
((:file "package")
(:file "reload")
(:file "conditions")
(:file "ffi")
(:file "ffi-buffer-all")
(:file "ffi-buffer" :if-feature (:not :clisp))
(:file "ffi-buffer-clisp" :if-feature :clisp)
(:file "streams")
(:file "bio")
(:file "x509")
(:file "random")
(:file "context")
(:file "verify-hostname"))))
:in-order-to ((test-op (load-op :cl+ssl.test)))
:perform (test-op (op c) (symbol-call '#:5am '#:run! :cl+ssl)))
(defsystem :cl+ssl/config
:depends-on (:cffi)
:components ((:module "src"
:serial t
:components ((:file "config")))))
| 1,771 | Common Lisp | .asd | 48 | 26.083333 | 111 | 0.511912 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | affaddd584b8b8fac7bbb63b848d1b7f82bc6f34ee025344fb8b0f8d9b27c824 | 43,075 | [
-1
] |
43,076 | cl-cookie.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-cookie-20220707-git/cl-cookie.asd | #|
This file is a part of cl-cookie project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
#|
Author: Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage cl-cookie-asd
(:use :cl :asdf))
(in-package :cl-cookie-asd)
(defsystem cl-cookie
:version "0.1"
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (:proc-parse
:cl-ppcre
:quri
:local-time
:alexandria)
:components ((:file "src/cl-cookie"))
:description "HTTP cookie manager"
:long-description
#.(with-open-file (stream (merge-pathnames
#p"README.markdown"
(or *load-pathname* *compile-file-pathname*))
:if-does-not-exist nil
:direction :input)
(when stream
(let ((seq (make-array (file-length stream)
:element-type 'character
:fill-pointer t)))
(setf (fill-pointer seq) (read-sequence seq stream))
seq)))
:in-order-to ((test-op (test-op cl-cookie-test))))
| 1,157 | Common Lisp | .asd | 35 | 23.514286 | 74 | 0.550492 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 83b7d4477e4a8c523031ba751f1c311684ca570a046406124db29e3af4f506e1 | 43,076 | [
107375
] |
43,077 | cl-cookie-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-cookie-20220707-git/cl-cookie-test.asd | #|
This file is a part of cl-cookie project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage cl-cookie-test-asd
(:use :cl :asdf))
(in-package :cl-cookie-test-asd)
(defsystem cl-cookie-test
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (:cl-cookie
:prove)
:components ((:module "t"
:components
((:test-file "cl-cookie"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove-asdf) c)
(asdf:clear-system c)))
| 646 | Common Lisp | .asd | 20 | 25.9 | 80 | 0.608347 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | f47cd497b5133466b8e471c7965d62eebfdd7319270c8f1973fcbd414b0d664a | 43,077 | [
237334
] |
43,078 | vecto.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/vecto-1.6/vecto.asd | ;;; Copyright (c) 2007 Zachary Beane, All Rights Reserved
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;;
;;; $Id: vecto.asd,v 1.10 2007/10/01 16:24:50 xach Exp $
(asdf:defsystem #:vecto
:depends-on (#:cl-vectors
#:zpng
#:zpb-ttf)
:version "1.6"
:author "Zach Beane <xach@xach.com>"
:description "Create vector graphics in PNG files."
:license "BSD"
:components ((:file "package")
(:file "utils"
:depends-on ("package"))
(:file "copy"
:depends-on ("package"))
(:file "color"
:depends-on ("package"
"copy"))
(:file "paths"
:depends-on ("package"))
(:file "transform-matrix"
:depends-on ("package"))
(:file "clipping-paths"
:depends-on ("package"
"copy"))
(:file "graphics-state"
:depends-on ("package"
"color"
"clipping-paths"
"transform-matrix"
"copy"))
(:file "drawing"
:depends-on ("package"
"utils"
"paths"
"graphics-state"
"transform-matrix"))
(:file "text"
:depends-on ("package"
"transform-matrix"
"graphics-state"
"drawing"))
(:file "arc"
:depends-on ("package"))
(:file "user-drawing"
:depends-on ("package"
"utils"
"clipping-paths"
"graphics-state"
"transform-matrix"
"text"
"arc"))
(:file "gradient"
:depends-on ("package"
"graphics-state"))
(:file "user-shortcuts"
:depends-on ("user-drawing"))))
| 3,685 | Common Lisp | .asd | 82 | 29 | 70 | 0.485698 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 25ff73653a7433270943108e4b77ab4e71856d0f10b860ac8adb0bcdf6b5653a | 43,078 | [
264060
] |
43,079 | vectometry.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/vecto-1.6/vectometry/vectometry.asd | ;;;; vectometry.asd
(asdf:defsystem #:vectometry
:author "Zach Beane <xach@xach.com>"
:description "2d drawing to PNGs with a more object-y interface than Vecto."
:license "BSD"
:depends-on (#:vecto)
:serial t
:components ((:file "package")
(:file "point")
(:file "box")
(:file "matrix")
(:file "operations")
(:file "vectometry")
(:file "colors")
(:file "box-text")))
| 487 | Common Lisp | .asd | 15 | 23.533333 | 78 | 0.529787 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | befed209f386c3d5fbb0f773ba772ed32c6a6e3b3d6596b71dfd4d5b78df872c | 43,079 | [
320505
] |
43,080 | xsubseq-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/xsubseq-20170830-git/xsubseq-test.asd | #|
This file is a part of xsubseq project.
Copyright (c) 2014 Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage xsubseq-test-asd
(:use :cl :asdf))
(in-package :xsubseq-test-asd)
(defsystem xsubseq-test
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (:xsubseq
:prove)
:components ((:module "t"
:components
((:test-file "xsubseq")
(:file "benchmark"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove-asdf) c)
(asdf:clear-system c)))
| 671 | Common Lisp | .asd | 21 | 25 | 80 | 0.5966 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 1b14c7b4752c6877e14e7b57f77bf9884a15c70d7b9e76722007fd1931e3f786 | 43,080 | [
305758
] |
43,081 | xsubseq.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/xsubseq-20170830-git/xsubseq.asd | #|
This file is a part of xsubseq project.
Copyright (c) 2014 Eitaro Fukamachi (e.arrows@gmail.com)
|#
#|
Author: Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage xsubseq-asd
(:use :cl :asdf))
(in-package :xsubseq-asd)
(defsystem xsubseq
:version "0.1"
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (#+sbcl :sb-cltl2)
:components ((:module "src"
:components
((:file "xsubseq"))))
:description "Efficient way to manage \"subseq\"s in Common Lisp"
:long-description
#.(with-open-file (stream (merge-pathnames
#p"README.markdown"
(or *load-pathname* *compile-file-pathname*))
:if-does-not-exist nil
:direction :input)
(when stream
(let ((seq (make-array (file-length stream)
:element-type 'character
:fill-pointer t)))
(setf (fill-pointer seq) (read-sequence seq stream))
seq)))
:in-order-to ((test-op (test-op xsubseq-test))))
| 1,139 | Common Lisp | .asd | 33 | 25.30303 | 74 | 0.562103 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 0196c321b93ad609d31866472728f6ee7c8476dbb46f6320acea372f11684027 | 43,081 | [
16339
] |
43,082 | chunga.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/chunga-20221106-git/chunga.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; $Header: /usr/local/cvsrep/chunga/chunga.asd,v 1.20 2008/05/24 18:38:30 edi Exp $
;;; Copyright (c) 2006-2010, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(asdf:defsystem :chunga
:serial t
:version "1.1.7"
:license "BSD"
:depends-on (:trivial-gray-streams)
:components ((:file "packages")
(:file "specials")
(:file "util")
(:file "known-words")
(:file "conditions")
(:file "read")
(:file "streams")
(:file "input")
(:file "output")))
| 1,922 | Common Lisp | .asd | 37 | 47.27027 | 85 | 0.689196 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 6ae64feda8520382e3e0fb1d144b007db76c6813e66f8617ece942d74c93d6db | 43,082 | [
-1
] |
43,083 | fast-http.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/fast-http-20191007-git/fast-http.asd | #|
This file is a part of fast-http project.
URL: http://github.com/fukamachi/fast-http
Copyright (c) 2014 Eitaro Fukamachi <e.arrows@gmail.com>
|#
(in-package :cl-user)
(defpackage fast-http-asd
(:use :cl :asdf))
(in-package :fast-http-asd)
(defsystem fast-http
:name "Fast HTTP Parser"
:description "A fast HTTP protocol parser in Common Lisp"
:version "0.2.0"
:author "Eitaro Fukamachi"
:license "MIT"
:depends-on (:alexandria
:cl-utilities
:proc-parse
:babel
:xsubseq
#+fast-http-debug
:log4cl
:smart-buffer)
:components ((:module "src"
:components
((:file "fast-http" :depends-on ("http" "parser" "multipart-parser" "byte-vector" "error"))
(:file "http")
(:file "parser" :depends-on ("http" "error" "byte-vector" "util"))
(:file "multipart-parser" :depends-on ("parser" "byte-vector" "error"))
(:file "byte-vector")
(:file "error")
(:file "util" :depends-on ("error")))))
:long-description
#.(with-open-file (stream (merge-pathnames
#p"README.markdown"
(or *load-pathname* *compile-file-pathname*))
:if-does-not-exist nil
:direction :input)
(when stream
(let ((seq (make-array (file-length stream)
:element-type 'character
:fill-pointer t)))
(setf (fill-pointer seq) (read-sequence seq stream))
seq)))
:in-order-to ((test-op (test-op fast-http-test))))
;; XXX: On ECL, it fails if loading a FASL file of parser.lisp.
;; This is an ugly workaround for now, as I don't get why it happens.
#+ecl
(defmethod asdf:perform :after ((op asdf:load-op) (c (eql (asdf:find-system :fast-http))))
(load (asdf:system-relative-pathname :fast-http #P"src/parser.lisp")))
| 2,045 | Common Lisp | .asd | 50 | 30.24 | 107 | 0.551482 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | b27ed522d79be43b6e0b98594374eff21ae4b360b345d1ab68dcb06d1ce2d38b | 43,083 | [
391402
] |
43,084 | fast-http-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/fast-http-20191007-git/fast-http-test.asd | #|
This file is a part of fast-http project.
URL: http://github.com/fukamachi/fast-http
Copyright (c) 2014 Eitaro Fukamachi <e.arrows@gmail.com>
|#
(in-package :cl-user)
(defpackage fast-http-test-asd
(:use :cl :asdf))
(in-package :fast-http-test-asd)
(defsystem fast-http-test
:depends-on (:fast-http
:babel
:cl-syntax-interpol
:xsubseq
:prove)
:components ((:module "t"
:components
((:test-file "parser" :depends-on ("test-utils"))
(:test-file "fast-http" :depends-on ("test-utils"))
(:test-file "multipart-parser" :depends-on ("test-utils"))
(:test-file "util")
(:file "test-utils")
(:file "benchmark"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove.asdf) c)
(asdf:clear-system c)))
| 998 | Common Lisp | .asd | 27 | 27.222222 | 80 | 0.548554 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 3327477a3789a1b3e0845986220b799bce212fd759aaa701abbb31348c6afa31 | 43,084 | [
411642
] |
43,085 | cl-postgres+local-time.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/local-time-20220707-git/cl-postgres+local-time.asd | (defsystem #:cl-postgres+local-time
:name "cl-postgres+local-time"
:version "1.0.6"
:author "Daniel Lowe <dlowe@dlowe.net>"
:description "Integration between cl-postgres and local-time"
:depends-on (:cl-postgres :local-time)
:components ((:module "src"
:components ((:module "integration"
:components ((:file "cl-postgres")))))))
| 388 | Common Lisp | .asd | 9 | 35.666667 | 70 | 0.630607 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e01af16f4b0e30b72c52e06c308ef501bc4aa597d56c65c4612ebfc9e15a0ae9 | 43,085 | [
318628
] |
43,086 | local-time.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/local-time-20220707-git/local-time.asd | (defsystem "local-time"
:version "1.0.6"
:license "BSD"
:author "Daniel Lowe <dlowe@dlowe.net>"
:description "A library for manipulating dates and times, based on a paper by Erik Naggum"
:depends-on (:uiop)
:in-order-to ((test-op (test-op "local-time/test")))
:components ((:module "src"
:serial t
:components ((:file "package")
(:file "local-time")))))
(defsystem "local-time/test"
:version "1.0.6"
:author "Daniel Lowe <dlowe@dlowe.net>"
:description "Testing code for the local-time library"
:depends-on (:hu.dwim.stefil
:local-time)
:perform (test-op (o s) (uiop:symbol-call '#:hu.dwim.stefil
'#:funcall-test-with-feedback-message
(uiop:find-symbol* '#:test '#:local-time.test)))
:components ((:module "test"
:serial t
:components ((:file "package")
(:file "simple")
(:file "comparison")
(:file "formatting")
(:file "parsing")
(:file "timezone")))))
| 1,246 | Common Lisp | .asd | 28 | 29.5 | 92 | 0.486442 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 705aae12052fe7d41502fa2c1def772f9ecaab7100b7184000a4c39d7a7e1d01 | 43,086 | [
-1
] |
43,087 | cl-ppcre.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-ppcre-20220220-git/cl-ppcre.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre.asd,v 1.49 2009/10/28 07:36:15 edi Exp $
;;; This ASDF system definition was kindly provided by Marco Baringer.
;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(defsystem :cl-ppcre
:version "2.1.1"
:description "Perl-compatible regular expression library"
:author "Dr. Edi Weitz"
:license "BSD"
:serial t
:components ((:file "packages")
(:file "specials")
(:file "util")
(:file "errors")
(:file "charset")
(:file "charmap")
(:file "chartest")
#-:use-acl-regexp2-engine
(:file "lexer")
#-:use-acl-regexp2-engine
(:file "parser")
#-:use-acl-regexp2-engine
(:file "regex-class")
#-:use-acl-regexp2-engine
(:file "regex-class-util")
#-:use-acl-regexp2-engine
(:file "convert")
#-:use-acl-regexp2-engine
(:file "optimize")
#-:use-acl-regexp2-engine
(:file "closures")
#-:use-acl-regexp2-engine
(:file "repetition-closures")
#-:use-acl-regexp2-engine
(:file "scanner")
(:file "api"))
:in-order-to ((test-op (test-op :cl-ppcre/test))))
(defsystem :cl-ppcre/test
:description "Perl-compatible regular expression library tests"
:author "Dr. Edi Weitz"
:license "BSD"
:depends-on (:cl-ppcre :flexi-streams)
:components ((:module "test"
:serial t
:components ((:file "packages")
(:file "tests")
(:file "perl-tests"))))
:perform (test-op (o c)
(funcall (intern (symbol-name :run-all-tests)
(find-package :cl-ppcre-test)))))
| 3,308 | Common Lisp | .asd | 70 | 38.057143 | 89 | 0.608359 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 71854b2382842612da08f64549cf0555f685f15c574286b5c208e3bdbf0fea82 | 43,087 | [
-1
] |
43,088 | cl-ppcre-unicode.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-ppcre-20220220-git/cl-ppcre-unicode.asd | ;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode.asd,v 1.15 2009/09/17 19:17:30 edi Exp $
;;; This ASDF system definition was kindly provided by Marco Baringer.
;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(defsystem :cl-ppcre-unicode
:description "Perl-compatible regular expression library (Unicode)"
:author "Dr. Edi Weitz"
:license "BSD"
:components ((:module "cl-ppcre-unicode"
:serial t
:components ((:file "packages")
(:file "resolver"))))
:depends-on (:cl-ppcre :cl-unicode)
:in-order-to ((test-op (test-op :cl-ppcre-unicode/test))))
(defsystem :cl-ppcre-unicode/test
:description "Perl-compatible regular expression library tests (Unicode)"
:author "Dr. Edi Weitz"
:license "BSD"
:depends-on (:cl-ppcre-unicode :cl-ppcre/test)
:components ((:module "test"
:serial t
:components ((:file "unicode-tests"))))
:perform (test-op (o c)
(funcall (intern (symbol-name :run-all-tests)
(find-package :cl-ppcre-test))
:more-tests (intern (symbol-name :unicode-test)
(find-package :cl-ppcre-test)))))
| 2,654 | Common Lisp | .asd | 47 | 49.680851 | 97 | 0.672951 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 3f3c650dc917b0fca73466af75f86a09f88bee6003628207c1e92cba684c86bc | 43,088 | [
446889
] |
43,089 | winhttp.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/winhttp-20200610-git/winhttp.asd | ;;;; Copyright (c) Frank James 2017 <frank.a.james@gmail.com>
;;;; This code is licensed under the MIT license.
(asdf:defsystem :winhttp
:name "winhttp"
:author "Frank James <frank.a.james@gmail.com>"
:description "FFI wrapper to WINHTTP"
:license "MIT"
:serial t
:components
((:file "package")
(:file "ffi")
(:file "util"))
:depends-on (:cffi))
| 371 | Common Lisp | .asd | 13 | 25.615385 | 61 | 0.678873 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c9b9132225edb9048db1f3b48e349123749e15843f0f3b7e138ef5b9207c34f5 | 43,089 | [
467206
] |
43,090 | cl-aa.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-vectors-20180228-git/cl-aa.asd | ;;;; -*- Lisp -*- mode
;;;; cl-vectors -- Rasterizer and paths manipulation library
;;;; Copyright (C) 2007-2013 Frédéric Jolliton <frederic@jolliton.com>
;;;; This code is licensed under the MIT license.
(defsystem "cl-aa"
:description "cl-aa: polygon rasterizer"
;; :VERSION "$VERSION$"
:author "Frederic Jolliton <frederic@jolliton.com>"
:licence "MIT"
:components ((:file "aa")
(:file "aa-bin")))
| 431 | Common Lisp | .asd | 11 | 35.545455 | 71 | 0.668269 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 85ff8924f48094df11567487874451129da7b943e8835e61e175ee3c1758fc8e | 43,090 | [
-1
] |
43,091 | cl-paths.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-vectors-20180228-git/cl-paths.asd | ;;;; -*- Lisp -*- mode
;;;; cl-vectors -- Rasterizer and paths manipulation library
;;;; Copyright (C) 2007-2013 Frédéric Jolliton <frederic@jolliton.com>
;;;; This code is licensed under the MIT license.
(defsystem "cl-paths"
:description "cl-paths: vectorial paths manipulation"
;; :version "$VERSION$"
:author "Frederic Jolliton <frederic@jolliton.com>"
:licence "MIT"
:components ((:file "paths-package")
(:file "paths" :depends-on ("paths-package"))
(:file "paths-annotation" :depends-on ("paths-package" "paths"))))
| 567 | Common Lisp | .asd | 12 | 42.583333 | 81 | 0.669691 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 43240ff17bb9ab8ca2f76b6a2abb8b98a4bb674f2b015a7e73be876fc74e91bb | 43,091 | [
-1
] |
43,092 | cl-aa-misc.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-vectors-20180228-git/cl-aa-misc.asd | ;;;; -*- Lisp -*- mode
;;;; cl-vectors -- Rasterizer and paths manipulation library
;;;; Copyright (C) 2007-2013 Frédéric Jolliton <frederic@jolliton.com>
;;;; This code is licensed under the MIT license.
(defsystem "cl-aa-misc"
:description "cl-aa-misc: some tools related to cl-aa"
;; :version "$VERSION$"
:author "Frederic Jolliton <frederic@jolliton.com>"
:licence "MIT"
:components ((:file "aa-misc")))
| 423 | Common Lisp | .asd | 10 | 39.9 | 71 | 0.699267 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 8a1809b0614fc58ca0b0b74db90ca69b4dc72e7111a4f2fc7850e97a28a6f66c | 43,092 | [
-1
] |
43,093 | cl-paths-ttf.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-vectors-20180228-git/cl-paths-ttf.asd | ;;;; -*- Lisp -*- mode
;;;; cl-vectors -- Rasterizer and paths manipulation library
;;;; Copyright (C) 2007-2013 Frédéric Jolliton <frederic@jolliton.com>
;;;; This code is licensed under the MIT license.
(defsystem "cl-paths-ttf"
:description "cl-paths-ttf: vectorial paths manipulation"
;; :version "$VERSION$"
:author "Frederic Jolliton <frederic@jolliton.com>"
:licence "MIT"
:depends-on ("cl-paths" "zpb-ttf")
:components ((:file "paths-ttf")))
| 467 | Common Lisp | .asd | 11 | 40 | 71 | 0.70354 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 8ba39e12cd0c5bffaa3dd06f492b38dc7a7b884ac54ecfdcec0bd0bae96f1282 | 43,093 | [
-1
] |
43,094 | cl-vectors.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-vectors-20180228-git/cl-vectors.asd | ;;;; -*- Lisp -*- mode
;;;; cl-vectors -- Rasterizer and paths manipulation library
;;;; Copyright (C) 2007-2013 Frédéric Jolliton <frederic@jolliton.com>
;;;; This code is licensed under the MIT license.
(defsystem "cl-vectors"
:description "cl-paths: vectorial paths manipulation"
;; :version "$VERSION$"
:author "Frederic Jolliton <frederic@jolliton.com>"
:licence "MIT"
:depends-on ("cl-aa" "cl-paths")
:components ((:file "vectors")))
| 457 | Common Lisp | .asd | 11 | 39.090909 | 71 | 0.70362 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | fb7f41eeb2b815bfcbd0792dafd13eea7493bde3630db501271e838f79413317 | 43,094 | [
-1
] |
43,095 | cffi-grovel.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/cffi-grovel.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi-grovel.asd --- ASDF system definition for cffi-grovel.
;;;
;;; Copyright (C) 2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(defsystem "cffi-grovel"
:description "The CFFI Groveller"
:author "Dan Knapp <dankna@accela.net>"
:depends-on ("cffi" "cffi-toolchain" "alexandria")
:licence "MIT"
:components
((:module "grovel"
:components
((:static-file "common.h")
(:file "package")
(:file "grovel" :depends-on ("package"))
(:file "asdf" :depends-on ("grovel"))))))
;; vim: ft=lisp et
| 1,684 | Common Lisp | .asd | 39 | 41.230769 | 70 | 0.72185 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 59d3e2c242c4d6cb52463cbb2301a09dd9c9bed7db8878a857398953727ee08a | 43,095 | [
76993,
292010
] |
43,098 | cffi.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/cffi.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi.asd --- ASDF system definition for CFFI.
;;;
;;; Copyright (C) 2005-2006, James Bielman <jamesjb@jamesjb.com>
;;; Copyright (C) 2005-2010, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(in-package :asdf)
#-(or openmcl mcl sbcl cmucl scl clisp lispworks ecl allegro cormanlisp abcl mkcl clasp)
(error "Sorry, this Lisp is not yet supported. Patches welcome!")
(defsystem "cffi"
:description "The Common Foreign Function Interface"
:author "James Bielman <jamesjb@jamesjb.com>"
:maintainer "Luis Oliveira <loliveira@common-lisp.net>"
:licence "MIT"
:depends-on (:uiop :alexandria :trivial-features :babel)
:in-order-to ((test-op (load-op :cffi-tests)))
:perform (test-op (o c) (operate 'asdf:test-op :cffi-tests))
:components
((:module "src"
:serial t
:components
((:file "cffi-openmcl" :if-feature :openmcl)
(:file "cffi-mcl" :if-feature :mcl)
(:file "cffi-sbcl" :if-feature :sbcl)
(:file "cffi-cmucl" :if-feature :cmucl)
(:file "cffi-scl" :if-feature :scl)
(:file "cffi-clisp" :if-feature :clisp)
(:file "cffi-lispworks" :if-feature :lispworks)
(:file "cffi-ecl" :if-feature :ecl)
(:file "cffi-allegro" :if-feature :allegro)
(:file "cffi-corman" :if-feature :cormanlisp)
(:file "cffi-abcl" :if-feature :abcl)
(:file "cffi-mkcl" :if-feature :mkcl)
(:file "cffi-clasp" :if-feature :clasp)
(:file "package")
(:file "utils")
(:file "libraries")
(:file "early-types")
(:file "types")
(:file "enum")
(:file "strings")
(:file "structures")
(:file "functions")
(:file "foreign-vars")
(:file "features")))))
;; when you get CFFI from git, its defsystem doesn't have a version,
;; so we assume it satisfies any version requirements whatsoever.
(defmethod version-satisfies ((c (eql (find-system :cffi))) version)
(declare (ignorable version))
(or (null (component-version c))
(call-next-method)))
(defsystem "cffi/c2ffi"
:description "CFFI definition generator from the FFI spec generated by c2ffi. This system can be used through ASDF's :DEFSYSTEM-DEPENDS-ON."
:author "Attila Lendvai <attila@lendvai.name>"
:depends-on (:alexandria
:cffi)
:licence "MIT"
:components
((:module "src/c2ffi"
:components
((:file "package")
(:file "c2ffi" :depends-on ("package"))
(:file "asdf" :depends-on ("package" "c2ffi"))))))
(defsystem "cffi/c2ffi-generator"
:description "This system gets loaded lazily when the CFFI bindings need to be regenerated. This only happens if the developer chose not to include the generated binding files, or the spec file generated by c2ffi has been modified."
:author "Attila Lendvai <attila@lendvai.name>"
:depends-on (:cffi/c2ffi
:cl-ppcre
:cl-json)
:licence "MIT"
:components
((:module "src/c2ffi"
:components
((:file "generator")))))
| 4,070 | Common Lisp | .asd | 95 | 39.147368 | 234 | 0.69287 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 627448d96f54cb2c4db9b13b3200162c826e9328dc2f2037ed491c9349bee2ad | 43,098 | [
279693
] |
43,099 | cffi-libffi.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/cffi-libffi.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi-libffi.asd --- Foreign Structures By Value
;;;
;;; Copyright (C) 2011 Liam M. Healy
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(in-package :asdf)
(eval-when (:compile-toplevel :execute)
(asdf:oos 'asdf:load-op :cffi-grovel)
(asdf:oos 'asdf:load-op :trivial-features))
(defsystem cffi-libffi
:description "Foreign structures by value"
:author "Liam Healy <lhealy@common-lisp.net>"
:maintainer "Liam Healy <lhealy@common-lisp.net>"
:defsystem-depends-on (#:trivial-features #:cffi-grovel)
:components
((:module libffi
:serial t
:components
((:file "libffi")
(cffi-grovel:grovel-file "libffi-types")
(:file "libffi-functions")
(:file "type-descriptors")
(:file "funcall"))))
:depends-on (#:cffi #:cffi-grovel #:trivial-features))
| 1,903 | Common Lisp | .asd | 45 | 40.111111 | 70 | 0.727763 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | de853489cb3dd0ea1db3670b68c465faa9ee5b10f05956ae865f731186833ec4 | 43,099 | [
163460,
358000
] |
43,100 | cffi-tests.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/cffi-tests.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi-tests.asd --- ASDF system definition for CFFI unit tests.
;;;
;;; Copyright (C) 2005-2006, James Bielman <jamesjb@jamesjb.com>
;;; Copyright (C) 2005-2011, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(load-systems "trivial-features" "cffi-grovel")
(defclass c-test-lib (c-source-file)
())
(defmethod perform ((o load-op) (c c-test-lib))
nil)
(defmethod perform ((o load-source-op) (c c-test-lib))
nil)
(defmethod output-files ((o compile-op) (c c-test-lib))
(let ((p (component-pathname c)))
(values
(list (make-pathname :defaults p :type (asdf/bundle:bundle-pathname-type :object))
(make-pathname :defaults p :type (asdf/bundle:bundle-pathname-type :shared-library)))
t)))
(defmethod perform ((o compile-op) (c c-test-lib))
(let ((cffi-toolchain:*cc-flags* `(,@cffi-toolchain:*cc-flags* "-Wall" "-std=c99" "-pedantic")))
(destructuring-bind (obj dll) (output-files o c)
(cffi-toolchain:cc-compile obj (input-files o c))
(cffi-toolchain:link-shared-library dll (list obj)))))
(defsystem "cffi-tests"
:description "Unit tests for CFFI."
:depends-on ("cffi-grovel" "cffi-libffi" "bordeaux-threads" #-ecl "rt" #+ecl (:require "rt"))
:components
((:module "tests"
:components
((:c-test-lib "libtest")
(:c-test-lib "libtest2")
(:c-test-lib "libfsbv")
(:file "package")
(:file "bindings" :depends-on ("package" "libtest" "libtest2" "libfsbv"))
(:file "funcall" :depends-on ("bindings"))
(:file "defcfun" :depends-on ("bindings"))
(:file "callbacks" :depends-on ("bindings"))
(:file "foreign-globals" :depends-on ("package"))
(:file "memory" :depends-on ("package"))
(:file "strings" :depends-on ("package"))
(:file "arrays" :depends-on ("package"))
(:file "struct" :depends-on ("package"))
(:file "union" :depends-on ("package"))
(:file "enum" :depends-on ("package"))
(:file "fsbv" :depends-on ("bindings" "enum"))
(:file "misc-types" :depends-on ("bindings"))
(:file "misc" :depends-on ("bindings"))
(:file "test-asdf" :depends-on ("package"))
(:file "grovel" :depends-on ("package")))))
:perform (test-op (o c) (symbol-call :cffi-tests '#:run-all-cffi-tests)))
(defsystem "cffi-tests/example"
:defsystem-depends-on ("cffi-grovel")
:entry-point "cffi-example::entry-point"
:components
((:module "examples" :components
((:file "package")
(:cffi-wrapper-file "wrapper-example" :depends-on ("package"))
(:cffi-grovel-file "grovel-example" :depends-on ("package"))
(:file "main-example" :depends-on ("package"))))))
;;; vim: ft=lisp et
| 3,798 | Common Lisp | .asd | 82 | 42.829268 | 98 | 0.676288 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e214dfa650038bb80668505be2cd28d827b50564d18ce285f7926d0282bae2f1 | 43,100 | [
249423
] |
43,101 | cffi-toolchain.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cffi-20221106-git/cffi-toolchain.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi-toolchain.asd --- ASDF system definition for cffi-toolchain.
;;;
;;; Copyright (C) 2007, Luis Oliveira <loliveira@common-lisp.net>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
;; Make sure to upgrade ASDF before the #.(if ...) below may be read.
(load-system "asdf")
#-asdf3.1 (error "CFFI-toolchain requires ASDF 3.1!")
(defsystem "cffi-toolchain"
:description "The CFFI toolchain"
:long-description "Portable abstractions for using the C compiler, linker, etc."
:author "Francois-Rene Rideau <fahree@gmail.com>"
:depends-on ((:version "asdf" "3.1.2") "cffi")
:licence "MIT"
:components
((:module "toolchain"
:components
(;; This is a plain copy of bundle.lisp from ASDF 3.2.0
;; in case your asdf isn't up to snuff.
(:file "bundle" :if-feature (#.(if (version< "3.1.8" (asdf-version)) :or :and)))
(:file "package")
(:file "c-toolchain" :depends-on ("package"))
(:file "static-link" :depends-on ("bundle" "c-toolchain"))))))
;; vim: ft=lisp et
| 2,117 | Common Lisp | .asd | 45 | 44.933333 | 85 | 0.713388 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | e6d9412dcf5cece1efef111ee07c90a9665ff109eadd76a508a146411f68db1a | 43,101 | [
269833
] |
43,104 | cl-json.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-json-20220707-git/cl-json.asd | ;;; -*- Mode: LISP; Syntax: ANSI-COMMON-LISP; Base: 10 -*-
;;; Copyright (c) 2006-2012 Henrik Hjelte
;;; Copyright (c) 2008 Hans Hübner (code from the program YASON)
;;; All rights reserved.
;;; See the file LICENSE for terms of use and distribution.
(defpackage #:json-system
(:use :cl :asdf :uiop))
(in-package #:json-system)
(pushnew :cl-json *features*)
#-no-cl-json-clos ;; Does not work with SBCL 1.0.17, this is a way to turn it off
(progn
#+(or mcl openmcl cmu sbcl clisp ecl scl lispworks allegro abcl genera)
(pushnew :cl-json-clos *features*))
(defsystem :cl-json
:name "cl-json"
:description "JSON in Lisp. JSON (JavaScript Object Notation) is a lightweight data-interchange format."
:version "0.6.0"
:author "Henrik Hjelte <henrik@henrikhjelte.com>"
:maintainer "Robert P. Goldman <rpgoldman@sift.net>"
:licence "MIT"
:in-order-to ((test-op (test-op "cl-json/test")))
:components ((:module "src"
:components ((:file "package")
(:file "common" :depends-on ("package"))
#+cl-json-clos
(:file "objects" :depends-on ("package"))
(:file "camel-case" :depends-on ("package"))
(:file "decoder" :depends-on ("common" #+cl-json-clos "objects" "camel-case"))
(:file "encoder" :depends-on ("common" #+cl-json-clos "objects" "camel-case"))
(:file "utils" :depends-on ("decoder" "encoder"))
(:file "json-rpc" :depends-on ("package" "common" "utils" "encoder" "decoder"))))))
(defsystem :cl-json/test
:depends-on (:cl-json :fiveam )
:components ((:module :t
:components ((:file "package")
(:file "testmisc" :depends-on ("package" "testdecoder" "testencoder"))
(:file "testdecoder" :depends-on ("package"))
(:file "testencoder" :depends-on ("package"))))))
(defmethod perform ((op test-op) (c (eql (find-system :cl-json/test))))
(funcall (intern (symbol-name '#:run!) :it.bese.FiveAM)
(intern (symbol-name '#:json) :json-test)))
(defparameter *cl-json-directory*
(system-relative-pathname "cl-json" ""))
| 2,301 | Common Lisp | .asd | 43 | 43.255814 | 112 | 0.581406 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 42cab3589276b54b65ccefc18ee9b5391c3460afc022ab99eb1e48f629fef01a | 43,104 | [
-1
] |
43,105 | puri.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/puri-20201016-git/puri.asd | ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*-
;;;; Programmer: Kevin Rosenberg
(in-package #:cl-user)
(defpackage #:puri-system (:use #:cl #:asdf))
(in-package #:puri-system)
(defsystem puri
:name "cl-puri"
:maintainer "Kevin M. Rosenberg <kmr@debian.org>"
:licence "GNU Lesser General Public License"
:description "Portable Universal Resource Indentifier Library"
:components
((:file "src"))
:in-order-to ((test-op (test-op "puri/test"))))
(defsystem puri/test
:depends-on (:ptester :puri)
:components
((:file "tests"))
:perform (test-op (o s)
(or (funcall (intern (symbol-name '#:do-tests)
(find-package '#:puri/test)))
(error "test-op failed"))))
| 775 | Common Lisp | .asd | 21 | 30.619048 | 68 | 0.608 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 7cbaeb85786193594f80106125aa03e28324c722ce473f24457ec1ab4f083e7f | 43,105 | [
-1
] |
43,106 | proc-parse.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/proc-parse-20190813-git/proc-parse.asd | #|
This file is a part of proc-parse project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
#|
Author: Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage proc-parse-asd
(:use :cl :asdf))
(in-package :proc-parse-asd)
(defsystem proc-parse
:version "0.1"
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (:alexandria
:babel
#+sbcl :sb-cltl2)
:components ((:module "src"
:components
((:file "proc-parse"))))
:description "Procedural vector parser"
:long-description
#.(with-open-file (stream (merge-pathnames
#p"README.markdown"
(or *load-pathname* *compile-file-pathname*))
:if-does-not-exist nil
:direction :input)
(when stream
(let ((seq (make-array (file-length stream)
:element-type 'character
:fill-pointer t)))
(setf (fill-pointer seq) (read-sequence seq stream))
seq)))
:in-order-to ((test-op (test-op proc-parse-test))))
| 1,180 | Common Lisp | .asd | 35 | 24.114286 | 74 | 0.551664 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | df529c8c088db15d0c5cf1e156c6215762e093de1982b9c5953aa989011b2c11 | 43,106 | [
283044
] |
43,107 | proc-parse-test.asd | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/proc-parse-20190813-git/proc-parse-test.asd | #|
This file is a part of proc-parse project.
Copyright (c) 2015 Eitaro Fukamachi (e.arrows@gmail.com)
|#
(in-package :cl-user)
(defpackage proc-parse-test-asd
(:use :cl :asdf))
(in-package :proc-parse-test-asd)
(defsystem proc-parse-test
:author "Eitaro Fukamachi"
:license "BSD 2-Clause"
:depends-on (:proc-parse
:prove)
:components ((:module "t"
:components
((:test-file "proc-parse"))))
:defsystem-depends-on (:prove-asdf)
:perform (test-op :after (op c)
(funcall (intern #.(string :run-test-system) :prove-asdf) c)
(asdf:clear-system c)))
| 652 | Common Lisp | .asd | 20 | 26.2 | 80 | 0.612083 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 5516045954511fdbe87c1dbb2bcd283674a76fe31d6cc26b77bf2e2f65ff2e4d | 43,107 | [
295034
] |
43,128 | abcl-socket.txt | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/notes/abcl-socket.txt |
ABCL provides a callback interface to java objects, next to these calls:
- ext:make-socket
- ext:socket-close
- ext:make-server-socket
- ext:socket-accept
- ext:get-socket-stream (returning an io-stream)
abcl-swank (see SLIME) shows how to call directly into java.
See for the sockets implementation:
- src/org/armedbear/lisp
* socket.lisp
* socket_stream.java
* SocketStream.java
| 402 | Common Lisp | .cl | 12 | 30.75 | 72 | 0.768229 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | abcacad51845623cba9bd00eb842efa6903c9cf4ea71b96d2bcb4487c04858c0 | 43,128 | [
-1
] |
43,129 | openmcl-sockets.txt | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/notes/openmcl-sockets.txt | http://openmcl.clozure.com/Doc/sockets.html
make-socket [Function]
accept-connection [Function]
dotted-to-ipaddr [Function]
ipaddr-to-dotted [Function]
ipaddr-to-hostname [Function]
lookup-hostname [Function]
lookup-port [Function]
receive-from [Function]
send-to [Function]
shutdown [Function]
socket-os-fd [Function]
remote-port [Function]
local-host [Function]
local-port [Function]
socket-address-family [Function]
socket-connect [Function]
socket-format [Function]
socket-type [Function]
socket-error [Class]
socket-error-code [Function]
socket-error-identifier [Function]
socket-error-situation [Function]
close [method]
| 726 | Common Lisp | .cl | 24 | 25.125 | 43 | 0.711016 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 160f468b5aad7c11553463ca6e95d85ad0a139d30cbf16fca4cd2640b90ee0a6 | 43,129 | [
-1
] |
43,130 | cmucl-sockets.txt | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/usocket-0.8.5/notes/cmucl-sockets.txt | http://cvs2.cons.org/ftp-area/cmucl/doc/cmu-user/internet.html
$Id$
extensions:lookup-host-entry host
[structure]
host-entry
name aliases addr-type addr-list
[Function]
extensions:create-inet-listener port &optional kind &key :reuse-address :backlog :interface
=> socket fd
[Function]
extensions:accept-tcp-connection unconnected
=> socket fd, address
[Function]
extensions:connect-to-inet-socket host port &optional kind
=> socket fd
[Function]
extensions:close-socket socket
[Private function]
extensions::get-peer-host-and-port socket-fd
[Private function]
extentsions::get-socket-host-and-port socket-fd
There's currently only 1 condition to be raised:
SOCKET-ERROR (derived from SIMPLE-ERROR)
which has a SOCKET-ERRNO slot containing the unix error number.
[Function]
extensions:add-oob-handler fd char handler
[Function]
extensions:remove-oob-handler fd char
[Function]
extensions:remove-all-oob-handlers fd
[Function]
extensions:send-character-out-of-band fd char
[Function]
extensions:create-inet-socket &optional type
=> socket fd
[Function]
extensions:get-socket-option socket level optname
[Function]
extensions:set-socket-option socket level optname optval
[Function]
extensions:ip-string addr
| 1,260 | Common Lisp | .cl | 41 | 28.414634 | 91 | 0.814442 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 831f5d244a8d98221eb937d6d66daca623be72c8ea5d5d08299fe651b24abc8c | 43,130 | [
-1
] |
43,150 | Eucla | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/local-time-20220707-git/zoneinfo/Australia/Eucla | TZif2 € œN¸0œ¼2„ËTÄ”ËÇiÌ·hͧK ñ ¶X§u)%R)¯¿”Eq´”F\”G#rGîyITIÎ[ÿÿÿ xÐ ‰ {
‰ {
LMT +0945 +0845 TZif2 ÿÿÿÿt¦
°ÿÿÿÿœN¸0ÿÿÿÿœ¼2„ÿÿÿÿËTÄ”ÿÿÿÿËÇiÿÿÿÿÌ·hÿÿÿÿͧK ñ ¶ X §u )%R )¯¿” Eq´” F\” G#r Gîy IT IÎ[ ÿÿÿ xÐ ‰ {
‰ {
LMT +0945 +0845
<+0845>-8:45
| 494 | Common Lisp | .cl | 7 | 69.571429 | 190 | 0.291581 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 6bb8d75e96cd4b2ac222bdb6b6d61a2ad0c76a5d3a85ddb4f289ed9abc27cc47 | 43,150 | [
-1
] |
43,166 | lunch.lsp | NailykSturm_Info805-TP/src/lunch.lsp | ; Gestionnaire de librarie de Common Lisp pour importer les autres librairies depuis internet
(require "quicklisp" "src/Import/quicklisp/setup.lisp")
; Importation des librairies
(quicklisp:quickload "dexador") ; Librairie pour faire des requêtes HTTP
(quicklisp:quickload "cl-json") ; Librairie pour parser du JSON
; Chargement des fichiers sources du projet
;(load "src/BDC/faits.lsp")
;(load "src/BDC/regles.lsp")
;(load "src/Exeptions/exept.lsp")
;(load "src/Moteur/moteur.lsp")
(load "src/UI/ui.lsp")
; Main
; (ui:testUI)
(ui:main)
; Test de la librairie dexador + cl-json
; (print
; (cl-json:decode-json-from-string
; (dex:get "https://pokeapi.co/api/v2/type/1")
; )
; ) | 699 | Common Lisp | .l | 20 | 33.7 | 93 | 0.734815 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 194b77a3569159c0b37a167f8687469dc8f9035b9c82b90dd5e72eab3e42016e | 43,166 | [
-1
] |
43,167 | exept.lsp | NailykSturm_Info805-TP/src/Exeptions/exept.lsp | (defpackage #:exept
(:use #:cl)
(:export #:exept #:test)
)
(in-package #:exept)
(defun test ()
(format t "test form exept~%")
) | 136 | Common Lisp | .l | 8 | 15 | 34 | 0.609375 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | b7544b13f5aea762c040b429b4844c1c878d791c4767ab54a7e101e5624c1f9b | 43,167 | [
-1
] |
43,191 | releases.txt | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/releases.txt | # project url size file-md5 content-sha1 prefix [system-file1..system-fileN]
1am http://beta.quicklisp.org/archive/1am/2014-11-06/1am-20141106-git.tgz 3490 c5e83c329157518e3ebfeef63e4ac269 83dfee1159cc630cc2453681a7caaf745f987d41 1am-20141106-git 1am.asd
3b-bmfont http://beta.quicklisp.org/archive/3b-bmfont/2022-03-31/3b-bmfont-20220331-git.tgz 8641 1ca28dc90f2821f1909eb73ac1c919c0 714899b97c11ebe96ef903a11817ce09b170d3ab 3b-bmfont-20220331-git 3b-bmfont.asd
3b-hdr http://beta.quicklisp.org/archive/3b-hdr/2020-09-25/3b-hdr-20200925-git.tgz 182755 09cc67fd82f54bab475eb7c6f9398faa 7d8d4c183aac97708d77283daf1ce247a25ca001 3b-hdr-20200925-git 3b-hdr.asd
3b-swf http://beta.quicklisp.org/archive/3b-swf/2012-01-07/3b-swf-20120107-git.tgz 75453 c130b35b44de03caa7cdf043d9d27dee 2dc75635c4d6a641618a63e61a9aa98252bbd2b7 3b-swf-20120107-git 3b-swf-swc.asd 3b-swf.asd
3bgl-shader http://beta.quicklisp.org/archive/3bgl-shader/2020-04-27/3bgl-shader-20200427-git.tgz 95653 b6cd3e5994902c8a6e841667bbfebe1c bc6c83bfe52c5e50aa8e41f6a353cc981476d6a1 3bgl-shader-20200427-git 3bgl-shader-example.asd 3bgl-shader.asd
3bmd http://beta.quicklisp.org/archive/3bmd/2022-07-07/3bmd-20220707-git.tgz 25952 f7cbf49b12fa470fe3cebb1d8c1ef2b9 b7560c27d7a3c4aa8ddf10ba92d10b84f73a120f 3bmd-20220707-git 3bmd-ext-code-blocks.asd 3bmd-ext-definition-lists.asd 3bmd-ext-math.asd 3bmd-ext-tables.asd 3bmd-ext-wiki-links.asd 3bmd-youtube-tests.asd 3bmd-youtube.asd 3bmd.asd
3bz http://beta.quicklisp.org/archive/3bz/2020-12-20/3bz-20201220-git.tgz 33098 a60b2ab5b383bfedeab4c127d164b853 51eeba0bbf0964e4f7a45042543a8480c503cb7c 3bz-20201220-git 3bz.asd
3d-matrices http://beta.quicklisp.org/archive/3d-matrices/2022-03-31/3d-matrices-20220331-git.tgz 43263 f5f13b1ab3357be804eae26a12fad77c 9d568427f6fa36e78b6a46fea0ee85c9931e66b0 3d-matrices-20220331-git 3d-matrices-test.asd 3d-matrices.asd
3d-quaternions http://beta.quicklisp.org/archive/3d-quaternions/2022-11-06/3d-quaternions-20221106-git.tgz 14931 fb4a2ef4581c7883fc525dc3808f4c72 f9006042024e18cde33202f81c7ab1b08c1c43f1 3d-quaternions-20221106-git 3d-quaternions-test.asd 3d-quaternions.asd
3d-transforms http://beta.quicklisp.org/archive/3d-transforms/2022-03-31/3d-transforms-20220331-git.tgz 9617 51a46b516cd8a2f9a18e239254cc1e24 482481bb8a9e3a5a7ff0f7963b53cfb14254a2fa 3d-transforms-20220331-git 3d-transforms-test.asd 3d-transforms.asd
3d-vectors http://beta.quicklisp.org/archive/3d-vectors/2022-11-06/3d-vectors-20221106-git.tgz 29549 993bc247aa898452f1cc123545d5cf3b ca4c6b3369bfc6b5c4fffd3fca54f01ef6e79b81 3d-vectors-20221106-git 3d-vectors-test.asd 3d-vectors.asd
40ants-asdf-system http://beta.quicklisp.org/archive/40ants-asdf-system/2022-11-06/40ants-asdf-system-20221106-git.tgz 4368 5b9c1f223cf3d1edc6a0a84495f5654a 11c592bc86197bf10a29ca5e1ba05c8250996f62 40ants-asdf-system-20221106-git 40ants-asdf-system.asd
a-cl-logger http://beta.quicklisp.org/archive/a-cl-logger/2022-03-31/a-cl-logger-20220331-git.tgz 18775 cb879ce95653e5651b18839845b7ad09 5b900ebb45096e77b20b4edbc4bc9618bf45854c a-cl-logger-20220331-git a-cl-logger-logstash.asd a-cl-logger.asd
able http://beta.quicklisp.org/archive/able/2017-12-27/able-20171227-git.tgz 30476 bf42d58fb2f32f239e9f98561fb11be1 3d1693e9704ba4fcd19a151baf16e3600447d83b able-20171227-git able.asd
abstract-arrays http://beta.quicklisp.org/archive/abstract-arrays/2022-11-06/abstract-arrays-20221106-git.tgz 9584 f21907790ce3148a050d9813d40e7add f3c4b0994353d38c1a484bb853468d72727a3466 abstract-arrays-20221106-git abstract-arrays.asd
access http://beta.quicklisp.org/archive/access/2022-07-07/access-20220707-git.tgz 14684 b7f64a742caf1d5a1dbc4eee614703ee cd51a17e1bf7588058b767f7eb54597b4dc8d918 access-20220707-git access.asd
acclimation http://beta.quicklisp.org/archive/acclimation/2022-11-06/acclimation-20221106-git.tgz 6241 988de4fdc9712ab129df433c0cf24715 724c3bcaa0b56004c9caf3f6abd76ff21673ccfe acclimation-20221106-git Temperature/acclimation-temperature.asd acclimation.asd
action-list http://beta.quicklisp.org/archive/action-list/2022-11-06/action-list-20221106-git.tgz 13096 e454f9f31f0e277b46a4d8d3ac2eb72f acb8ab9528355552e92972a20476475f1d216136 action-list-20221106-git action-list.asd
adhoc http://beta.quicklisp.org/archive/adhoc/2022-03-31/adhoc-20220331-git.tgz 309177 7580aa5e43a36e8ca4ffe0d8e8d7d9d1 8079841b6ea89eb3f482e95b473d7678980d8338 adhoc-20220331-git adhoc-tests.asd adhoc.asd
adopt http://beta.quicklisp.org/archive/adopt/2022-03-31/adopt-20220331-hg.tgz 24761 bc066e05fa9eec803f69ff6b6b142b1d 811e2413d8530f20a8f62b3e76fc0546b7e7804a adopt-20220331-hg adopt.asd
adopt-subcommands http://beta.quicklisp.org/archive/adopt-subcommands/2021-05-31/adopt-subcommands-v0.2.2.tgz 10475 66bc9a0c3b0797aaf4244d40ac6ea03e 853b9148d18112a9a7c7ed53002f536c4f233a58 adopt-subcommands-v0.2.2 adopt-subcommands-test.asd adopt-subcommands.asd
adp http://beta.quicklisp.org/archive/adp/2022-11-06/adp-20221106-git.tgz 47668 c0aa03fedf8367ff1eafbcc09b98aa90 70c1e9639107731071844edcdf3781c7430f67e0 adp-20221106-git adp.asd
advanced-readtable http://beta.quicklisp.org/archive/advanced-readtable/2013-07-20/advanced-readtable-20130720-git.tgz 10570 bcb3c8a4757047bf7a41117265b74a3f 163baeafd28c4f4cb0c3fb42529df5ee75a711cc advanced-readtable-20130720-git advanced-readtable.asd
aether http://beta.quicklisp.org/archive/aether/2021-12-09/aether-v1.1.0.tgz 52398 c44a7ba571b139605bbf17c4b5cd3176 74a1e54230e1e4cebd54568c94c920c620708666 aether-v1.1.0 aether-tests.asd aether.asd
agnostic-lizard http://beta.quicklisp.org/archive/agnostic-lizard/2022-11-06/agnostic-lizard-20221106-git.tgz 32519 1dde4a11c3d831d5ba7118aaf583fef7 68f930dcd9330b85affea18199f9880a0b582190 agnostic-lizard-20221106-git agnostic-lizard-debugger-prototype.asd agnostic-lizard.asd
agutil http://beta.quicklisp.org/archive/agutil/2021-05-31/agutil-20210531-git.tgz 7087 99de7cd320ae2696c1707ca5b55cf40a e0472fd8324ea893d6cb8ae7225015d881938010 agutil-20210531-git agutil.asd
ahungry-fleece http://beta.quicklisp.org/archive/ahungry-fleece/2020-06-10/ahungry-fleece-20200610-git.tgz 95571 d0513c178f95e1b039255fdc7abf2158 02c3cee458071001e3993f325d2c02bfa17ded41 ahungry-fleece-20200610-git ahungry-fleece.asd skel/skeleton.asd
alexa http://beta.quicklisp.org/archive/alexa/2018-08-31/alexa-20180831-git.tgz 11101 322aae1831d32c65e4f7512a749e5794 d27375e85ec943d49b3fcb77b3ab606b2dd63e92 alexa-20180831-git alexa-tests.asd alexa.asd
alexandria http://beta.quicklisp.org/archive/alexandria/2022-07-07/alexandria-20220707-git.tgz 56838 b99150be4c664857c2d29fcaee7a3421 3ddb9890ee52585da5d9ab071a067677dba79a2a alexandria-20220707-git alexandria.asd
alexandria-plus http://beta.quicklisp.org/archive/alexandria-plus/2022-11-06/alexandria-plus-20221106-git.tgz 200298 1914fbe89e36fbc3290b3a6837d152b8 6aa8350b1dd34ff4fc2203f1e04d6e46111e6a10 alexandria-plus-20221106-git alexandria+.asd
algebraic-data-library http://beta.quicklisp.org/archive/algebraic-data-library/2018-08-31/algebraic-data-library-20180831-git.tgz 2657 4e0c9d6480ef5824821e38ef88ce7c0f 35e8cb9da56cd9b6f4bc6bbd9b6e7094f28e367a algebraic-data-library-20180831-git algebraic-data-library.asd
also-alsa http://beta.quicklisp.org/archive/also-alsa/2022-07-07/also-alsa-20220707-git.tgz 13834 01541a5ca990deab87d93e354d17dcb2 88ac5159a97642c6ce4940997693b7368a7373be also-alsa-20220707-git also-alsa.asd
amazon-ecs http://beta.quicklisp.org/archive/amazon-ecs/2011-04-18/amazon-ecs-20110418-git.tgz 18915 6fdd5ad095bd4a492e0d5cd07b7fae98 f8aa169d0a8e927a8357b210570f72d0198d630d amazon-ecs-20110418-git amazon-ecs.asd
amb http://beta.quicklisp.org/archive/amb/2022-02-20/amb-20220220-git.tgz 7936 392000310cca34fcb3f58c9f4320caa8 4b147240557d00e69627fbd3b12882cfdd403780 amb-20220220-git amb.asd
anaphora http://beta.quicklisp.org/archive/anaphora/2022-02-20/anaphora-20220220-git.tgz 6303 f773589c518c8fd4d1be7baf2ff757a3 327160e2015ef1a72e6b98977c8dcde00b8ef2ea anaphora-20220220-git anaphora.asd
anaphoric-variants http://beta.quicklisp.org/archive/anaphoric-variants/2012-10-13/anaphoric-variants-1.0.1.tgz 3961 1958c6eed506b8dd7f7ebf4fb85142ed affec75bb8b78489722f937336342d2e003695db anaphoric-variants-1.0.1 anaphoric-variants.asd
anatevka http://beta.quicklisp.org/archive/anatevka/2022-11-06/anatevka-v1.0.0.tgz 59207 2a1d8820217793f1788960b1d7d3f1ca e981edb8939aa9001f40bee236913931ea45d0b8 anatevka-v1.0.0 anatevka-tests.asd anatevka.asd
antik http://beta.quicklisp.org/archive/antik/2019-10-08/antik-master-df14cb8c-git.tgz 1655490 1bfdd37b226dd77d2a83a8262c7f5c75 027e6a3fca896a523a6cd49cb6ae501605c6d953 antik-master-df14cb8c-git antik-base.asd antik.asd foreign-array.asd physical-dimension.asd science-data.asd
anypool http://beta.quicklisp.org/archive/anypool/2021-05-31/anypool-20210531-git.tgz 6088 c752d80e52cc4b64c8b671c3fc58c7fd 4de957af66eedc303fb342784e3d6ee20f64398b anypool-20210531-git anypool.asd lack-middleware-anypool.asd
apply-argv http://beta.quicklisp.org/archive/apply-argv/2015-06-08/apply-argv-20150608-git.tgz 2451 d6c331fb609e14d8e99c2c5235767ae5 41176149bfe25382fbeee01eef0ca9aaca6aa6ec apply-argv-20150608-git apply-argv.asd
april http://beta.quicklisp.org/archive/april/2022-07-07/april-20220707-git.tgz 265123 4b7feb9fe517714159b5d2e5706b7cb9 268713f1077d6171d7616988dff3ec17af9da0d5 april-20220707-git aplesque/aplesque.asd april.asd demos/cnn/april-demo.cnn.asd demos/ncurses/april-demo.ncurses.asd libraries/dfns/array/april-lib.dfns.array.asd libraries/dfns/graph/april-lib.dfns.graph.asd libraries/dfns/numeric/april-lib.dfns.numeric.asd libraries/dfns/power/april-lib.dfns.power.asd libraries/dfns/string/april-lib.dfns.string.asd libraries/dfns/tree/april-lib.dfns.tree.asd maxpc-apache/maxpc-apache.asd vex/vex.asd
arc-compat http://beta.quicklisp.org/archive/arc-compat/2022-03-31/arc-compat-20220331-git.tgz 69019 68d46922fc1fde93ea196b59a3f6cdfb 6b675a56446b4f22b61be3887119ff660e17f132 arc-compat-20220331-git arc-compat.asd
architecture.builder-protocol http://beta.quicklisp.org/archive/architecture.builder-protocol/2022-11-06/architecture.builder-protocol-20221106-git.tgz 48668 36e4b1e7fef0851ce1fff4964a58ea59 208c0474daedb09d106013354dba3689b544caeb architecture.builder-protocol-20221106-git architecture.builder-protocol.asd architecture.builder-protocol.inspection.asd architecture.builder-protocol.json.asd architecture.builder-protocol.print-tree.asd architecture.builder-protocol.universal-builder.asd architecture.builder-protocol.xpath.asd
architecture.hooks http://beta.quicklisp.org/archive/architecture.hooks/2018-12-10/architecture.hooks-20181210-git.tgz 15541 698bdb1309cae19fb8f0e1e425ba4cd9 c5d4bd17509ba19d55913a247ef56853d51a4169 architecture.hooks-20181210-git cl-hooks.asd
architecture.service-provider http://beta.quicklisp.org/archive/architecture.service-provider/2019-10-07/architecture.service-provider-20191007-git.tgz 22626 7260877f29b3fe3ad6e94126360f0bd3 9ae3133023dfc49a6e891ce2a3d1eefdc25c0513 architecture.service-provider-20191007-git architecture.service-provider-and-hooks.asd architecture.service-provider.asd
archive http://beta.quicklisp.org/archive/archive/2016-03-18/archive-20160318-git.tgz 19507 5332faf00d7b8416c0468770fa9aaf1f 83bcf90b745c5d8967086741072f3b7496733868 archive-20160318-git archive.asd
arithmetic-operators-as-words http://beta.quicklisp.org/archive/arithmetic-operators-as-words/2020-06-10/arithmetic-operators-as-words-20200610-git.tgz 1443 8318181de7b11bd524aaf15f595615a6 3f27abd9563ba2d59a546085e1c3d9cde3215558 arithmetic-operators-as-words-20200610-git arithmetic-operators-as-words.asd
arnesi http://beta.quicklisp.org/archive/arnesi/2017-04-03/arnesi-20170403-git.tgz 84553 bbb34e1a646b2cc489766690c741d964 c83ef816a3596038ebc507611c2c17bb822a1024 arnesi-20170403-git arnesi.asd
array-operations http://beta.quicklisp.org/archive/array-operations/2022-07-07/array-operations-1.0.0.tgz 352381 7cb89adc0a97d66adb3c23d352116199 4ec8bb709ee312eae007365f54cb38b0672e6723 array-operations-1.0.0 array-operations.asd
array-utils http://beta.quicklisp.org/archive/array-utils/2022-11-06/array-utils-20221106-git.tgz 5975 777f19e789fe5d44aa2d9ab91cc716a1 9f2676c45c7e73a4fe5ec97204e90c2d3db12d1c array-utils-20221106-git array-utils-test.asd array-utils.asd
arrival http://beta.quicklisp.org/archive/arrival/2021-12-09/arrival-20211209-git.tgz 207106 01522ff0010a4061f541f2c57dfa9a07 a2394c5c45002581e0f3cfc0431ce0e2d1c1b1ad arrival-20211209-git arrival.asd
arrow-macros http://beta.quicklisp.org/archive/arrow-macros/2020-12-20/arrow-macros-20201220-git.tgz 6170 e88ff276ed8c1701d36d72dd2ba93dc4 959ad0c1e73017a47a8721165fc28b670c45e8ce arrow-macros-20201220-git arrow-macros-test.asd arrow-macros.asd
arrows http://beta.quicklisp.org/archive/arrows/2018-10-18/arrows-20181018-git.tgz 5067 c60b5d79680de19baad018a0fe87bc48 82ebf99cf60c78e451f73e515b418f7c2f40b18b arrows-20181018-git arrows.asd
asd-generator http://beta.quicklisp.org/archive/asd-generator/2019-01-07/asd-generator-20190107-git.tgz 17944 3d89b79133f9d2e7bff3e7735a299f96 b9e465de3e179e7a7c0b73aa62be878777b014ea asd-generator-20190107-git asd-generator.asd test/asd-generator-test.asd
asdf-dependency-grovel http://beta.quicklisp.org/archive/asdf-dependency-grovel/2017-04-03/asdf-dependency-grovel-20170403-git.tgz 41965 e5f32a1e82dd83fa6446c28c2e43a73d ecfb684ceed8f4a95d124aa4f5398ec35a2dc5e2 asdf-dependency-grovel-20170403-git asdf-dependency-grovel.asd tests/test-serial-system.asd
asdf-encodings http://beta.quicklisp.org/archive/asdf-encodings/2019-10-07/asdf-encodings-20191007-git.tgz 9259 76bd0a61aa4df19e683d16592e0e62cd e3a8f15e4b8e4c4b39d4bcbbb67c6e7c308cf3d1 asdf-encodings-20191007-git asdf-encodings.asd
asdf-finalizers http://beta.quicklisp.org/archive/asdf-finalizers/2022-11-06/asdf-finalizers-20221106-git.tgz 6608 91f4b318b51986184f3d4570d6eefb52 3838733d2c72f1dfc49fd2adb186f490d9f4601a asdf-finalizers-20221106-git asdf-finalizers.asd list-of.asd
asdf-flv http://beta.quicklisp.org/archive/asdf-flv/2016-04-21/asdf-flv-version-2.1.tgz 2116 2b74b721b7e5335d2230d6b95fc6be56 7f61773346be3e61c241d597d02a3ec533d15989 asdf-flv-version-2.1 net.didierverna.asdf-flv.asd
asdf-linguist http://beta.quicklisp.org/archive/asdf-linguist/2015-09-23/asdf-linguist-20150923-git.tgz 4653 110db875b9d5cbdbc41fff8b50cc6688 b5929afb75c89ab6729d90da79686bc0885d7b55 asdf-linguist-20150923-git asdf-linguist.asd
asdf-manager http://beta.quicklisp.org/archive/asdf-manager/2016-02-08/asdf-manager-20160208-git.tgz 3156 67452d33f1e027b145ca8bfd0fa2806c eda6b453d5d3481e2d4e164c3206ae84012e7edd asdf-manager-20160208-git asdf-manager-test.asd asdf-manager.asd
asdf-package-system http://beta.quicklisp.org/archive/asdf-package-system/2015-06-08/asdf-package-system-20150608-git.tgz 1383 9eee9d811aec4894843ac1d8ae6cbccd 910495edcf74671f08ba09181539bf644e0cbb3f asdf-package-system-20150608-git asdf-package-system.asd
asdf-system-connections http://beta.quicklisp.org/archive/asdf-system-connections/2017-01-24/asdf-system-connections-20170124-git.tgz 4933 23bdbb69c433568e3e15ed705b803992 c49a358d1e61207c282e985905eae1810205fc2b asdf-system-connections-20170124-git asdf-system-connections.asd
asdf-viz http://beta.quicklisp.org/archive/asdf-viz/2020-06-10/asdf-viz-20200610-git.tgz 4137355 39c59335d40c2659e6091818ca8a207c be6f6901c363b7919b006c30c7a34ccff61248ed asdf-viz-20200610-git asdf-viz.asd
aserve http://beta.quicklisp.org/archive/aserve/2021-12-09/aserve-20211209-git.tgz 524184 7bfef6f4c9ca23b31eed3f82cc0b77f7 f516da5921d99d4de0d20ef4e6c974cc1199a374 aserve-20211209-git zaserve.asd
asn1 http://beta.quicklisp.org/archive/asn1/2022-03-31/asn1-20220331-git.tgz 5680 cd75024e68a69a16f4d75e7d1039a926 a7c5c3e14ebdf88c72206ed0908485185c321ac2 asn1-20220331-git asn1.asd
assert-p http://beta.quicklisp.org/archive/assert-p/2020-06-10/assert-p-20200610-git.tgz 17334 be2bb62f2e88664c514771abca4b0f7f f5a85d7f2dca68cee7c9800fbeed09254e4c81fe assert-p-20200610-git assert-p.asd
assertion-error http://beta.quicklisp.org/archive/assertion-error/2019-12-27/assertion-error-20191227-git.tgz 14185 797ad3c5cad14fb25eec76ccfb79b66a d9aff6bf141a59631d4371eace22a865bd29b0e6 assertion-error-20191227-git assertion-error.asd
assoc-utils http://beta.quicklisp.org/archive/assoc-utils/2022-11-06/assoc-utils-20221106-git.tgz 3346 31f7e9581f26f46e3a1faf8054a1b9e3 47726262f7d343bd4e1487213512c94447325c24 assoc-utils-20221106-git assoc-utils-test.asd assoc-utils.asd
asteroids http://beta.quicklisp.org/archive/asteroids/2019-10-07/asteroids-20191007-git.tgz 3522066 e6956f404d402140e6573e24d849fc7d 89a44fb3225d6525e4bd26d20992a10ae2a0917a asteroids-20191007-git asteroids.asd
astonish http://beta.quicklisp.org/archive/astonish/2021-01-24/astonish-20210124-git.tgz 15247 916d460e9a7245bae98f7b6dd0624096 cc4a3529a123420f92d3ec89b0925b74435d0750 astonish-20210124-git astonish.asd
async-process http://beta.quicklisp.org/archive/async-process/2021-05-31/async-process-20210531-git.tgz 309213 c382958d8638e1862c82b8815ac29a5a 026520b995abd94284df9c9737dedd9008781686 async-process-20210531-git src/async-process.asd
atdoc http://beta.quicklisp.org/archive/atdoc/2012-03-05/atdoc-20120305-git.tgz 36850 e9c40fd27b136fd9db0d0f13dc7d51a7 e60e3ca611b8eb9ff908091482932c14a119066a atdoc-20120305-git atdoc.asd example/blocks-world.asd
atomics http://beta.quicklisp.org/archive/atomics/2021-06-30/atomics-20210630-git.tgz 8265 25ab51fdd4d325ec6ca450037d4cbb3f 4afd3410480a8d7f3341576f37b9af9c8200bc32 atomics-20210630-git atomics-test.asd atomics.asd
audio-tag http://beta.quicklisp.org/archive/audio-tag/2021-05-31/audio-tag-20210531-git.tgz 10075 b6830b2edb7c5ca12bd090e351b8c408 014212d5271772cbde7b51c8c4b4a029cc5c49ba audio-tag-20210531-git audio-tag.asd
authenticated-encryption http://beta.quicklisp.org/archive/authenticated-encryption/2018-10-18/authenticated-encryption-20181018-git.tgz 3639 02feacbc3a7b22144c368c498d5c4376 e966e0e3779ca5769c995cf4dc16e241c708a37f authenticated-encryption-20181018-git authenticated-encryption-test.asd authenticated-encryption.asd
auto-restart http://beta.quicklisp.org/archive/auto-restart/2022-11-06/auto-restart-20221106-git.tgz 9648 3ba908d56d0b9c2c2303dc0bb53e9d1c 9a3dc452410014bd161b0b395ddb375f97c84126 auto-restart-20221106-git auto-restart.asd
autoexport http://beta.quicklisp.org/archive/autoexport/2021-10-20/autoexport-20211020-git.tgz 2029 120310ec516c312fe9c3beb0748725f2 ab588be898104c35422832e55470fb95c0fa0ff6 autoexport-20211020-git autoexport.asd
avatar-api http://beta.quicklisp.org/archive/avatar-api/2015-06-08/avatar-api-20150608-git.tgz 2129 52a2e667536e10f80124ae2436f5d9a6 9fda0ec095f9fbdb8073605703d792a0eb3e8398 avatar-api-20150608-git avatar-api-test.asd avatar-api.asd
avl-tree http://beta.quicklisp.org/archive/avl-tree/2022-07-07/avl-tree-20220707-git.tgz 3953 7ab19b2c7b65ee678af10e4ccb9d4623 ec3e3cb1b0216220cb887bae7ecb236c562cc2e0 avl-tree-20220707-git avl-tree.asd
aws-foundation http://beta.quicklisp.org/archive/aws-foundation/2018-07-11/aws-foundation-20180711-git.tgz 4880 1cc177097ef8968147370f9970f04174 a973090f169db7cbacba714b68499f442b084902 aws-foundation-20180711-git aws-foundation.asd
aws-sign4 http://beta.quicklisp.org/archive/aws-sign4/2020-12-20/aws-sign4-20201220-git.tgz 35606 52b5e933857d6fcd6d9ae09d96749994 670ce82da4d18c9f30c13ae086246e14fd530e9d aws-sign4-20201220-git aws-sign4.asd
ayah-captcha http://beta.quicklisp.org/archive/ayah-captcha/2018-02-28/ayah-captcha-20180228-git.tgz 4660 396998f1fc484ded0afe3209ff00a380 59257d29def50e9701cdef4d34f13242cc85db4b ayah-captcha-20180228-git ayah-captcha.asd demo/ayah-captcha-demo.asd
babel http://beta.quicklisp.org/archive/babel/2020-09-25/babel-20200925-git.tgz 273336 7f64d3be80bcba19d9caeaede5dea6d8 3883704943f463c50718758d466e69d9cc794965 babel-20200925-git babel-streams.asd babel-tests.asd babel.asd
base-blobs http://beta.quicklisp.org/archive/base-blobs/2020-10-16/base-blobs-stable-git.tgz 3079693 7a1c3235949ef927220323889dce7249 8f7937f45ea5d3a21575fbf1040324ed215cbb8c base-blobs-stable-git base-blobs.asd
base64 http://beta.quicklisp.org/archive/base64/2018-10-18/base64-20181018-git.tgz 2014 e7d77c873d9111e6e0a6704422805b24 3d8e62f5d3313d09e1a9ecd8d66f25b24eb58e73 base64-20181018-git base64.asd
basic-binary-ipc http://beta.quicklisp.org/archive/basic-binary-ipc/2021-12-09/basic-binary-ipc-20211209-git.tgz 58637 7f583c2411e886d3ddd4a90b37f3a9dc 3a0def3af86e1570ff7d37dd97306f3ad6cbf27d basic-binary-ipc-20211209-git basic-binary-ipc-tests.asd basic-binary-ipc.asd
bdef http://beta.quicklisp.org/archive/bdef/2022-11-06/bdef-20221106-git.tgz 19687 37510cac5db5ba0b409a7c561a730643 0cda5d2997100769d9bb2ba45d1a49c0d00bc78b bdef-20221106-git bdef.asd
beast http://beta.quicklisp.org/archive/beast/2021-10-20/beast-20211020-hg.tgz 12339 a088a4e43b030e5ff48e562e94b80db7 1e373942753fe2895c3b3b34877d91e320c7fb7d beast-20211020-hg beast.asd
beirc http://beta.quicklisp.org/archive/beirc/2015-05-05/beirc-20150505-git.tgz 27301 50b1ea2e799d918ee68ff607f2ed7c98 091f2c11d2b297704101697235a411841ceb23ad beirc-20150505-git beirc.asd
big-string http://beta.quicklisp.org/archive/big-string/2019-03-07/big-string-20190307-hg.tgz 3949 bdffed5d0ef77e065911aba09e1bdf8c 5489c493ce7ca3c482880797a0d80c9c84e91384 big-string-20190307-hg big-string.asd
bike http://beta.quicklisp.org/archive/bike/2022-07-07/bike-20220707-git.tgz 78962 17cd85f35b856d28aa04d23fbc79f449 f5a670efd5302c0171e5c68744058c289e26e3f0 bike-20220707-git bike-examples.asd bike-internals.asd bike-tests.asd bike.asd
binary-io http://beta.quicklisp.org/archive/binary-io/2020-10-16/binary-io-20201016-git.tgz 9283 cc19c739c754326ce39f668c3edd603d 5b60a4449b7b4285c20c9fa33460f4eb2f5c7a97 binary-io-20201016-git binary-io.asd
binary-parser http://beta.quicklisp.org/archive/binary-parser/2022-07-07/binary-parser-20220707-git.tgz 2495 ee673e029b5a98fade080962422b27f8 7376509d40644a7113081c00f21ced67796b3ff3 binary-parser-20220707-git binary-parser.asd
binary-search-tree http://beta.quicklisp.org/archive/binary-search-tree/2022-07-07/binary-search-tree-20220707-git.tgz 3254 fb5752dfe2131214c386706e6117f820 5f2558000a5fa12c88316f309d3791d627f0018e binary-search-tree-20220707-git binary-search-tree.asd
binary-types http://beta.quicklisp.org/archive/binary-types/2013-06-15/binary-types-20130615-git.tgz 21337 e26f69cddf40a07beb89d9066830c44a 2f1a13a9ef75be93d53cf55d7c4c07260a620c3e binary-types-20130615-git binary-types.asd
binascii http://beta.quicklisp.org/archive/binascii/2015-07-09/binascii-20150709-git.tgz 196802 23f4db8372bd521725dd78dd667c2be1 e02502e8146770e87fa5b6e461b7729ee1117ad2 binascii-20150709-git binascii.asd
binding-arrows http://beta.quicklisp.org/archive/binding-arrows/2021-06-30/binding-arrows-20210630-git.tgz 12131 395c745f69dfec48737fb43fc931072a e6fc30da4383db57dec5db83864b5b4a24f111f0 binding-arrows-20210630-git binding-arrows.asd
binfix http://beta.quicklisp.org/archive/binfix/2019-08-13/binfix-20190813-git.tgz 103896 916f3d55cf63c374ff9afacf03f9e9cc b3848eabd74026fd5a24d290bff94cdacd7d6dd3 binfix-20190813-git binfix.asd
binomial-heap http://beta.quicklisp.org/archive/binomial-heap/2013-04-20/binomial-heap-20130420-git.tgz 6211 ca40cb01b88a3fe902cc4cc25fb2d242 81583c3945e9f392cb8943713ed18724f72296f2 binomial-heap-20130420-git binomial-heap.asd
binpack http://beta.quicklisp.org/archive/binpack/2022-07-07/binpack-20220707-git.tgz 65418 25b5b75c1f86dadd476d95075eb1912d ebcb15a7e1509dfbc8d4d49bd23706ff053ca7be binpack-20220707-git binpack-test.asd binpack.asd
birch http://beta.quicklisp.org/archive/birch/2022-02-20/birch-20220220-git.tgz 20542 d7b94daa0f1851bae5acdda905d589da b07baf6e919e6ab2ed540da9f1a17b22b0194472 birch-20220220-git birch.asd birch.test.asd
bit-ops http://beta.quicklisp.org/archive/bit-ops/2018-02-28/bit-ops-20180228-git.tgz 7131 487abc6e8afc586eb96300931a43d7be 923abf5d89d48ea17333f812c9c4bc1ab3092d90 bit-ops-20180228-git bit-ops.asd bit-ops.test.asd
bit-smasher http://beta.quicklisp.org/archive/bit-smasher/2022-11-06/bit-smasher-20221106-git.tgz 9053 516aac75a3ca28c5d7f7c5d2fd4683bc 8552278fad19ed76274364f37ba945999b600af6 bit-smasher-20221106-git bit-smasher-test.asd bit-smasher.asd
bitfield http://beta.quicklisp.org/archive/bitfield/2021-12-30/bitfield-20211230-git.tgz 6978 dcd68bdb6892f03bd1dbb17fb6a018c8 f9c2389f2b34e76652144ad95887111d59ff07ec bitfield-20211230-git code/bitfield.asd
bitfield-schema http://beta.quicklisp.org/archive/bitfield-schema/2012-01-07/bitfield-schema-20120107-git.tgz 6659 fac865d5c6379fd8e4a8526b99ec0662 5b4bf17a55e13ed80e657a545b9ea1ca5ceb77ec bitfield-schema-20120107-git bitfield-schema.asd
bitio http://beta.quicklisp.org/archive/bitio/2022-02-20/bitio-20220220-git.tgz 20937 05e53d3beed1200433f39106db8cc4c3 76d1eeb13197363c4a1715de9e4c4704e23c7781 bitio-20220220-git bitio.asd
bk-tree http://beta.quicklisp.org/archive/bk-tree/2013-04-20/bk-tree-20130420-git.tgz 21425 5ae53564f2a64abdc1424a054f965485 e0690274745029d8135d91abcdb18598e60e2999 bk-tree-20130420-git bk-tree.asd
bknr-datastore http://beta.quicklisp.org/archive/bknr-datastore/2022-02-20/bknr-datastore-20220220-git.tgz 630242 df1d3dd090e0f88ec0991c74d9872527 45b04866cea0ea3743cb018ed557dd36b97f1695 bknr-datastore-20220220-git src/bknr.data.impex.asd src/bknr.datastore.asd src/bknr.impex.asd src/bknr.indices.asd src/bknr.skip-list.asd src/bknr.utils.asd src/bknr.xml.asd
bknr-web http://beta.quicklisp.org/archive/bknr-web/2014-07-13/bknr-web-20140713-git.tgz 172044 e867c9d79b03ea02d3e8af6d5d4a1fd7 80c17f624bf44065d7992880117d8a2373cf6744 bknr-web-20140713-git modules/bknr.modules.asd modules/spider/leech.asd src/bknr.web.asd src/html-match/html-match.asd
black-tie http://beta.quicklisp.org/archive/black-tie/2022-07-07/black-tie-20220707-git.tgz 13783 9db759d346da259a336e656fa978adeb b06e4726fc01461e4073eb0584c21644b35558fc black-tie-20220707-git black-tie.asd
blackbird http://beta.quicklisp.org/archive/blackbird/2022-11-06/blackbird-20221106-git.tgz 12734 61e1103e5fa158485b11abf491e41417 d06ad3be5b9cf79694114945f36f506207fc6f22 blackbird-20221106-git blackbird-test.asd blackbird.asd
bnf http://beta.quicklisp.org/archive/bnf/2022-02-20/bnf-20220220-git.tgz 4209 bbe941af9603e210dcc8da1a2c52a758 684c928911467941546e798661338e373ccb840f bnf-20220220-git bnf.asd spec/bnf.test.asd
bobbin http://beta.quicklisp.org/archive/bobbin/2020-10-16/bobbin-20201016-hg.tgz 6329 d1153e0b4a8367d2bd2999d4b9d4ffc5 8e5f5d627e6bb104b54de473fb5abe916d1d680e bobbin-20201016-hg bobbin.asd
bodge-blobs-support http://beta.quicklisp.org/archive/bodge-blobs-support/2020-10-16/bodge-blobs-support-stable-git.tgz 2376 14151bc3bd37194b6d16a279e423ce03 f57f21f32160247bc3f674a73c7c165cdcc663f7 bodge-blobs-support-stable-git bodge-blobs-support.asd
bodge-chipmunk http://beta.quicklisp.org/archive/bodge-chipmunk/2020-10-16/bodge-chipmunk-stable-git.tgz 573748 d3d0ce97b33380a19f48b47c3735c37e f72a179ba3d13e849e1b61877fab83c0d99711e1 bodge-chipmunk-stable-git bodge-chipmunk.asd
bodge-concurrency http://beta.quicklisp.org/archive/bodge-concurrency/2020-10-16/bodge-concurrency-stable-git.tgz 4049 79a73e12c8c4a70871067f68dade5b9e bd81a970496d4163fe1394dde017faaa45681dd3 bodge-concurrency-stable-git bodge-concurrency.asd
bodge-glad http://beta.quicklisp.org/archive/bodge-glad/2020-10-16/bodge-glad-stable-git.tgz 55615 8696869c8bdaf569287ef8f1f31f3f15 d4f3c4bd83a053d7e9371a194a9cdacf31d35a12 bodge-glad-stable-git bodge-glad.asd
bodge-glfw http://beta.quicklisp.org/archive/bodge-glfw/2020-10-16/bodge-glfw-stable-git.tgz 806212 59b75f4c658ed119447fc68dcd7dc545 6d0e70f5fc86b33bb848db7041c25a776d8ea637 bodge-glfw-stable-git bodge-glfw.asd
bodge-heap http://beta.quicklisp.org/archive/bodge-heap/2020-10-16/bodge-heap-stable-git.tgz 3310 0f641e0438af5c6d9fd40199a2e663b8 5ef371ace55126b39d9be22d6415ea94cad524c3 bodge-heap-stable-git bodge-heap.asd
bodge-host http://beta.quicklisp.org/archive/bodge-host/2021-12-09/bodge-host-stable-git.tgz 11177 fa34933a06300625a432c29778c6ae61 67db398fc17c61936ce402a7af8a6d723a77dcfb bodge-host-stable-git bodge-host.asd
bodge-libc-essentials http://beta.quicklisp.org/archive/bodge-libc-essentials/2020-10-16/bodge-libc-essentials-stable-git.tgz 2264 91cd137de7bc7c81014e057320b15be6 f4e6073aff1f377285054ff52d1efae5a046b18c bodge-libc-essentials-stable-git bodge-libc-essentials.asd
bodge-math http://beta.quicklisp.org/archive/bodge-math/2020-10-16/bodge-math-stable-git.tgz 6347 5a37cba2138f762ac18c7819b082bae3 595bfd536066837202344127d1299fca02e78c71 bodge-math-stable-git bodge-math.asd
bodge-memory http://beta.quicklisp.org/archive/bodge-memory/2020-10-16/bodge-memory-stable-git.tgz 2712 40afeaca44d7157599420e1821743c34 9858f8a1f18d58a12755c79e88399d60c4de7b87 bodge-memory-stable-git bodge-memory.asd
bodge-nanovg http://beta.quicklisp.org/archive/bodge-nanovg/2020-10-16/bodge-nanovg-stable-git.tgz 2130841 56467b37c015a2207d72e52254a6ff1f f731ed3414124e777ffbc190baab60da9e505a70 bodge-nanovg-stable-git bodge-nanovg.asd
bodge-nuklear http://beta.quicklisp.org/archive/bodge-nuklear/2020-10-16/bodge-nuklear-stable-git.tgz 2014134 5f48d8782dbd8b30bfd3dbc664d3f412 29ad11538c79aa3a67feea7fde09d558927df4af bodge-nuklear-stable-git bodge-nuklear.asd
bodge-ode http://beta.quicklisp.org/archive/bodge-ode/2020-10-16/bodge-ode-stable-git.tgz 2330922 67af727dd796765c220516e430d1ae02 a45886fcaddce838dfad7822077f33ead66fbdf1 bodge-ode-stable-git bodge-ode.asd
bodge-openal http://beta.quicklisp.org/archive/bodge-openal/2020-10-16/bodge-openal-stable-git.tgz 847505 8767b3f5b6247665659180c5559debe4 42f4dab30f0461b5175d9cef9e4c0c17871c4383 bodge-openal-stable-git bodge-openal.asd
bodge-queue http://beta.quicklisp.org/archive/bodge-queue/2020-10-16/bodge-queue-stable-git.tgz 2583 1fa840983aa191d81fee17de2f2fc1ed 9de215906b47296d6e890603ee3083a9c8188ef1 bodge-queue-stable-git bodge-queue.asd
bodge-sndfile http://beta.quicklisp.org/archive/bodge-sndfile/2020-10-16/bodge-sndfile-stable-git.tgz 3990428 087ac59a98cc6a5d85d10f5fd64008d7 5f6dad7f7b32affa25840bd96832838f621da339 bodge-sndfile-stable-git bodge-sndfile.asd
bodge-utilities http://beta.quicklisp.org/archive/bodge-utilities/2022-07-07/bodge-utilities-stable-git.tgz 7697 f107197acafedd38240392fbc7b11a49 1650543412386b218ca1bc3619b71f9849ba1335 bodge-utilities-stable-git bodge-utilities.asd
bordeaux-fft http://beta.quicklisp.org/archive/bordeaux-fft/2015-06-08/bordeaux-fft-20150608-http.tgz 13857 99bee7dc569e71f40783551c792295bd a0caf5c27a3c3734178472333279926177ffb23a bordeaux-fft-20150608-http bordeaux-fft.asd
bordeaux-threads http://beta.quicklisp.org/archive/bordeaux-threads/2022-07-07/bordeaux-threads-v0.8.8.tgz 3029861 28d2015e426a29b67aeccf7469021c3c 517bf464180fef2fe81f877b716dd6ede1bba331 bordeaux-threads-v0.8.8 bordeaux-threads.asd
bourbaki http://beta.quicklisp.org/archive/bourbaki/2011-01-10/bourbaki-20110110-http.tgz 133787 64d23b156e8cf295c76a144e6522749b c224635f433be2ab0e45fd2e0ec13c6d735751ab bourbaki-20110110-http bourbaki.asd
bp http://beta.quicklisp.org/archive/bp/2022-11-06/bp-20221106-git.tgz 70654 92e82e627ce3d0e1480d38c6e88f574f f91faf16fbce4b3a9435f69d378f37a3fb6dcee5 bp-20221106-git bp.asd
bst http://beta.quicklisp.org/archive/bst/2022-11-06/bst-20221106-git.tgz 18634 4f0d375bce2ef4a3c89d0f40d69b3b53 d1f3a60bdd58d697f40429b19e352dc33c1ef5bd bst-20221106-git bst.asd
bt-semaphore http://beta.quicklisp.org/archive/bt-semaphore/2018-07-11/bt-semaphore-20180711-git.tgz 4185 f70c869eaf18e277056a16eb3a21fd4a 23d9c3966166a46e5c42bbdacab7a2f684bfcd0c bt-semaphore-20180711-git bt-semaphore-test.asd bt-semaphore.asd
btrie http://beta.quicklisp.org/archive/btrie/2014-07-13/btrie-20140713-git.tgz 6389 1fdf3a46133861b59f7a1063f5fe6696 9d9e506112d4b87225944df068090c68d4b2c563 btrie-20140713-git btrie.asd
bubble-operator-upwards http://beta.quicklisp.org/archive/bubble-operator-upwards/2012-11-25/bubble-operator-upwards-1.0.tgz 2943 390c6f1aad23154fc613a1941ab0ee90 e5c62a9e32928fc4e4d38f9949acd9b30b0a7187 bubble-operator-upwards-1.0 bubble-operator-upwards.asd
buildapp http://beta.quicklisp.org/archive/buildapp/2015-12-18/buildapp-1.5.6.tgz 16389 b6c1450b19370d7e4ac21bf565b62c89 33832bc72acbd9b3c4a097b054bd0de1921b873a buildapp-1.5.6 buildapp.asd
buildnode http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz 66725 b917f0d6c20489febbef0d5b954c350d dfe5d7aec7c73eb6797069f1d5b7fdc2d60fb610 buildnode-20170403-git buildnode-excel.asd buildnode-html5.asd buildnode-kml.asd buildnode-xhtml.asd buildnode-xul.asd buildnode.asd
burgled-batteries http://beta.quicklisp.org/archive/burgled-batteries/2016-08-25/burgled-batteries-20160825-git.tgz 42019 d20613a907e062fd32128fe25aead746 3124f87459f2bf2ad793179593df364aa383c3b1 burgled-batteries-20160825-git burgled-batteries-tests.asd burgled-batteries.asd
burgled-batteries.syntax http://beta.quicklisp.org/archive/burgled-batteries.syntax/2021-05-31/burgled-batteries.syntax-20210531-git.tgz 8237 bbee40c9fb275fa8e9e17f78e8f155b8 d239c8d9d3579d14f8905765be6caa9320b2816d burgled-batteries.syntax-20210531-git burgled-batteries.syntax-test.asd burgled-batteries.syntax.asd
bytecurry.asdf-ext http://beta.quicklisp.org/archive/bytecurry.asdf-ext/2015-05-05/bytecurry.asdf-ext-20150505-git.tgz 2750 9fb33756e2edcb3ab0074dd8c32b73e4 32af33d3211f1d3aa8cb3a32d125ee5e49ae4236 bytecurry.asdf-ext-20150505-git bytecurry.asdf-ext.asd
bytecurry.mocks http://beta.quicklisp.org/archive/bytecurry.mocks/2020-03-25/bytecurry.mocks-20200325-git.tgz 4189 9a0dfcbd9ead50439763674cd9fea60c 22bde407990ff5eecc36b47f3500716ef4de4811 bytecurry.mocks-20200325-git bytecurry.mocks.asd
c2ffi-blob http://beta.quicklisp.org/archive/c2ffi-blob/2020-10-16/c2ffi-blob-stable-git.tgz 31810192 c190cf57ac9b9fc4bee219269f478940 d4ac9c0ff84cb336d9f662c890ce80ac33b81182 c2ffi-blob-stable-git c2ffi-blob.asd
cacau http://beta.quicklisp.org/archive/cacau/2020-06-10/cacau-20200610-git.tgz 316796 9cfdc54a8168b70f0dd9a7d1ac99ec02 6d047cae0a43c3cc2a695ee06b481201091241f8 cacau-20200610-git cacau-asdf.asd cacau-test.asd cacau.asd examples/asdf-intregration/cacau-examples-asdf-integration-test.asd examples/asdf-intregration/cacau-examples-asdf-integration.asd
cache-while http://beta.quicklisp.org/archive/cache-while/2021-08-07/cache-while-20210807-git.tgz 1555 732b05f16109d0120c0616c1b7ab200f 760207de6a47fe0e26b31cdaf242de0f729c809d cache-while-20210807-git cache-while.asd
cacle http://beta.quicklisp.org/archive/cacle/2019-05-21/cacle-20190521-git.tgz 16699 8ea845a295a43d0794dc43c22d36ec2c edfe4bf4dc852fac85daf536ae908816aa269d28 cacle-20190521-git cacle.asd
calispel http://beta.quicklisp.org/archive/calispel/2017-08-30/calispel-20170830-git.tgz 28640 1fba6e4b2055f5d1f0a78387e29552b1 1035e7249ad45cc5fb7aa5d6e362b0a80fefb7b8 calispel-20170830-git calispel.asd
cambl http://beta.quicklisp.org/archive/cambl/2018-12-10/cambl-20181210-git.tgz 45991 e5857aaf953cfdb3ebb1c4c49a02e92c 8d9ad22f71869a88fa184ae7e2510e73ff7c669e cambl-20181210-git cambl-test.asd cambl.asd fprog.asd
can http://beta.quicklisp.org/archive/can/2018-03-28/can-20180328-git.tgz 2565 6ef0d28d5aa6bc2936078cc116b70f39 0e6ad110295f63dba70e4f4d5f467734c8b52e20 can-20180328-git can-test.asd can.asd
canonicalized-initargs http://beta.quicklisp.org/archive/canonicalized-initargs/2021-04-11/canonicalized-initargs_2.0.tgz 7268 1da53e811cdc982f3d4c208b48440e86 cecd08ca17ea43dbc1850e5bb807925e22796399 canonicalized-initargs_2.0 canonicalized-initargs.asd tests/canonicalized-initargs_tests.asd
caramel http://beta.quicklisp.org/archive/caramel/2013-04-20/caramel-20130420-git.tgz 4745 b6e6020c467971a5118dd7dba8276270 5d89e63be813fb25e31975f4d42db250aa2aecb2 caramel-20130420-git caramel.asd
cardiogram http://beta.quicklisp.org/archive/cardiogram/2021-10-20/cardiogram-20211020-git.tgz 11619 5784e0a9cb33e8b03dade402e02f3592 c97938b979095994667ecaf4362a886c21492b57 cardiogram-20211020-git cardiogram.asd example/cardioex.asd
cari3s http://beta.quicklisp.org/archive/cari3s/2020-03-25/cari3s-20200325-git.tgz 25096 393eb58f2f0e592f324d71a50c08f004 ed6be61d844c7a624978e7489bb62aaa19cc4e45 cari3s-20200325-git cari3s.asd
carrier http://beta.quicklisp.org/archive/carrier/2018-12-10/carrier-20181210-git.tgz 3881 f831e7a8f590a9c634eaacdc8f145fe5 d2f6c847ae390bf95b2b392f562fbe17e6530563 carrier-20181210-git carrier.asd
cartesian-product-switch http://beta.quicklisp.org/archive/cartesian-product-switch/2012-09-09/cartesian-product-switch-2.0.tgz 4502 0f48da4205f8cd3b201eae1e07131fcd 82200c07f66d5d80ebeb62388108699e03e27f49 cartesian-product-switch-2.0 cartesian-product-switch.asd
caveman http://beta.quicklisp.org/archive/caveman/2022-11-06/caveman-20221106-git.tgz 19305 d9a8e73fd4f9491806313d49b9f14166 89b0cd4720778dd458678901c32a9ef10b83fbc5 caveman-20221106-git caveman-middleware-dbimanager.asd caveman2-db.asd caveman2-test.asd caveman2.asd
caveman2-widgets http://beta.quicklisp.org/archive/caveman2-widgets/2018-02-28/caveman2-widgets-20180228-git.tgz 115350 960ba92d1ac86f49ce553bffd7136b25 446246d6fb1f1a2891175b7e88f45704fa72c728 caveman2-widgets-20180228-git caveman2-widgets-test.asd caveman2-widgets.asd
caveman2-widgets-bootstrap http://beta.quicklisp.org/archive/caveman2-widgets-bootstrap/2018-02-28/caveman2-widgets-bootstrap-20180228-git.tgz 4962 b6fc04d5468c9b3d6a502024eaaa8750 7ce56c2e7c5eb75f32208c90695e44a3006c10be caveman2-widgets-bootstrap-20180228-git caveman2-widgets-bootstrap-test.asd caveman2-widgets-bootstrap.asd
ccl-compat http://beta.quicklisp.org/archive/ccl-compat/2017-11-30/ccl-compat-20171130-git.tgz 7068 3229bd0be4ffa2a90e882433253a0100 fc117e973fdd6c08994c81baf99e5cc025877654 ccl-compat-20171130-git ccl-compat.asd
ccldoc http://beta.quicklisp.org/archive/ccldoc/2020-04-27/ccldoc-20200427-git.tgz 47058 27125f8c5fc4e77ed05d8b98c82c9d1a 6b9aa6ee639c5b054c84e6236306b5dd1d0a9189 ccldoc-20200427-git source/ccldoc-libraries.asd source/ccldoc.asd
cells http://beta.quicklisp.org/archive/cells/2021-10-20/cells-20211020-git.tgz 20819052 50d6f971e7f7ced93580991e2dbfdb5b 49c5235fd154b630c785941523c910666b970a64 cells-20211020-git cells.asd
cephes.cl http://beta.quicklisp.org/archive/cephes.cl/2022-11-06/cephes.cl-20221106-git.tgz 772297 271e2fa8cce16ad2318be8b66a075b93 90240be6e893076c0dcb9d3913f402cd2cefaca2 cephes.cl-20221106-git cephes.asd
cepl http://beta.quicklisp.org/archive/cepl/2021-02-28/cepl-release-quicklisp-d1a10b6c-git.tgz 436157 43cba4741a3ae9a738a7f7134cb4f156 aa98687dd705f2b00485cdd7ba40a4a1f45901b4 cepl-release-quicklisp-d1a10b6c-git cepl.asd cepl.build.asd
cepl.camera http://beta.quicklisp.org/archive/cepl.camera/2018-02-28/cepl.camera-release-quicklisp-1292212a-git.tgz 3590 ea3319909269d1defe329ae8e126a314 6ef8df0aa73f50df2b63f462301c0bf9331d6007 cepl.camera-release-quicklisp-1292212a-git cepl.camera.asd
cepl.devil http://beta.quicklisp.org/archive/cepl.devil/2018-02-28/cepl.devil-release-quicklisp-ea5f8514-git.tgz 1930 3ca7236c320de5b217c7cd924bf8e063 6b6f880612fd28a8573cc6b4795bfa663131cf83 cepl.devil-release-quicklisp-ea5f8514-git cepl.devil.asd
cepl.drm-gbm http://beta.quicklisp.org/archive/cepl.drm-gbm/2019-05-21/cepl.drm-gbm-20190521-git.tgz 4081 1303fc696e495ec12e2ece9ee4dc6344 b74136275913799eaae407b967c32eac5baec46c cepl.drm-gbm-20190521-git cepl.drm-gbm.asd
cepl.glop http://beta.quicklisp.org/archive/cepl.glop/2018-02-28/cepl.glop-release-quicklisp-8ec09801-git.tgz 2915 33579536bbfc7037efe4ee830ecaed5f b72f80288063b5d214cf27257d1bcdf8b703878b cepl.glop-release-quicklisp-8ec09801-git cepl.glop.asd
cepl.sdl2 http://beta.quicklisp.org/archive/cepl.sdl2/2018-02-28/cepl.sdl2-release-quicklisp-6da5a030-git.tgz 4119 8e30fec5d59a4cf8f21525d1cdb9f7d3 61e4d1868d907fc092236d7f6ad8b36b685b181c cepl.sdl2-release-quicklisp-6da5a030-git cepl.sdl2.asd
cepl.sdl2-image http://beta.quicklisp.org/archive/cepl.sdl2-image/2018-02-28/cepl.sdl2-image-release-quicklisp-94a77649-git.tgz 2449 7e83fbc6868c8a13579dd590377c15fa c784ddba948e3260da76df22b18b7cc41fba7fda cepl.sdl2-image-release-quicklisp-94a77649-git cepl.sdl2-image.asd
cepl.sdl2-ttf http://beta.quicklisp.org/archive/cepl.sdl2-ttf/2018-01-31/cepl.sdl2-ttf-release-quicklisp-11b498a3-git.tgz 2404 d5e31a84c08ec2bf453a0a9cf00fa4e9 7c4640f10b7220bee04db63eef4cbf6ecae2f757 cepl.sdl2-ttf-release-quicklisp-11b498a3-git cepl.sdl2-ttf.asd
cepl.skitter http://beta.quicklisp.org/archive/cepl.skitter/2018-02-28/cepl.skitter-release-quicklisp-f52b9240-git.tgz 1755 64a97da55e6074842428311cafc99bed 63f431bc9eaa088c5c77dda2f4d983c9aa17bfdb cepl.skitter-release-quicklisp-f52b9240-git cepl.skitter.glop.asd cepl.skitter.sdl2.asd
cepl.spaces http://beta.quicklisp.org/archive/cepl.spaces/2018-03-28/cepl.spaces-release-quicklisp-c7f83f26-git.tgz 24762 53d77882ea7a52043103f436138b5496 765133bddb709078ff096c43c9ff4d98cf8fabe2 cepl.spaces-release-quicklisp-c7f83f26-git cepl.spaces.asd
ceramic http://beta.quicklisp.org/archive/ceramic/2021-08-07/ceramic-20210807-git.tgz 86784 07197067eedb1db6de1e27d74f72a495 79c7d3bfc3315beb09afa2f9fcc36f08f54e0af8 ceramic-20210807-git ceramic.asd t/app/ceramic-test-app.asd
cerberus http://beta.quicklisp.org/archive/cerberus/2022-11-06/cerberus-20221106-git.tgz 1718735 324301e8c8784f6dd94942fad3797c81 430e102fc3926d67eb0c69eab66328095c68bcdb cerberus-20221106-git cerberus.asd
cesdi http://beta.quicklisp.org/archive/cesdi/2020-07-15/cesdi_1.0.1.tgz 6265 f98c6571658b61ac2c83125917250545 81c12dc086fb0c2f75ea1f8da8bdc027835736f2 cesdi_1.0.1 cesdi.asd tests/cesdi_tests.asd
cffi http://beta.quicklisp.org/archive/cffi/2022-11-06/cffi-20221106-git.tgz 263450 099adc34a6030e22f3469931664ce3fd 4ed8f9aadd3c5d13dde930c857b07c0f4c6d6ae6 cffi-20221106-git cffi-examples.asd cffi-grovel.asd cffi-libffi.asd cffi-tests.asd cffi-toolchain.asd cffi-uffi-compat.asd cffi.asd
cffi-c-ref http://beta.quicklisp.org/archive/cffi-c-ref/2020-10-16/cffi-c-ref-stable-git.tgz 4291 b97790196796d5231f13ae4b57059214 6bc0609f487c3d5d566c5f2e078361e3418a35dc cffi-c-ref-stable-git cffi-c-ref.asd
chain http://beta.quicklisp.org/archive/chain/2021-12-09/chain-20211209-git.tgz 1011 1663332e4a6262e9019a2397da3a38f3 25922dd7187baa100341af0b0ce2bc7ae7f387fd chain-20211209-git chain.asd
chameleon http://beta.quicklisp.org/archive/chameleon/2022-02-20/chameleon-v2.1.1.tgz 5863 895418e7a107ab0617627fbe578c5e4e 4cb3d3166e9dd801ddd66a2931a12dbc31624367 chameleon-v2.1.1 chameleon.asd
chancery http://beta.quicklisp.org/archive/chancery/2020-10-16/chancery-20201016-hg.tgz 15393 dd75eddc0307826b7035ff17abac679e e0a0e4441f2807a657d669ce84920556b142ca83 chancery-20201016-hg chancery.asd chancery.test.asd
changed-stream http://beta.quicklisp.org/archive/changed-stream/2013-01-28/changed-stream-20130128-git.tgz 233624 08dfb9234851b9bbe3d2b774efc809b6 153aecf366d19d2091f7e4c8a4aa22293cd0a66b changed-stream-20130128-git changed-stream.asd changed-stream.test.asd
chanl http://beta.quicklisp.org/archive/chanl/2021-04-11/chanl-20210411-git.tgz 27608 efaa5705b5feaa718290d25a95e2a684 0926e91860356aa2b291a418782e1a22cdf45d29 chanl-20210411-git chanl.asd
cheat-js http://beta.quicklisp.org/archive/cheat-js/2012-10-13/cheat-js-20121013-git.tgz 27000 d23fc2a4dfd3a0ce8c7fb42c773feb2d 288b962ed29320e097d0bf871dcd0189aa5de94d cheat-js-20121013-git cheat-js.asd
check-bnf http://beta.quicklisp.org/archive/check-bnf/2022-07-07/check-bnf-20220707-git.tgz 14160 a7bdaad354f4b3a094c0a3369bbbe1a2 91a97257278590771724c7cbab8a94c83f39c65f check-bnf-20220707-git check-bnf.asd spec/check-bnf.test.asd
check-it http://beta.quicklisp.org/archive/check-it/2015-07-09/check-it-20150709-git.tgz 19988 0baae55e5a9c8c884202cbc51e634c42 49933b16fc112096734546df0d91bb76bef3044e check-it-20150709-git check-it.asd
checkl http://beta.quicklisp.org/archive/checkl/2018-03-28/checkl-20180328-git.tgz 8294 a5050385e2ef2977ba2112ea88128535 aca1cf3498cb81a443772c0bc306b11e037d5dd6 checkl-20180328-git checkl-docs.asd checkl-test.asd checkl.asd
chemical-compounds http://beta.quicklisp.org/archive/chemical-compounds/2011-10-01/chemical-compounds-1.0.2.tgz 5119 05d45cf42a61e9dabab409d345b778c1 1fc077075d4b580f4b363a131f670bab602e8886 chemical-compounds-1.0.2 chemical-compounds.asd
chillax http://beta.quicklisp.org/archive/chillax/2015-03-02/chillax-20150302-git.tgz 207342 f173c34bb131fe6192f5c6c87bf1be7e 860cd942dd71757d22f1b81d24919e36cca850c5 chillax-20150302-git chillax.asd chillax.core.asd chillax.jsown.asd chillax.view-server.asd chillax.yason.asd
chipmunk-blob http://beta.quicklisp.org/archive/chipmunk-blob/2020-10-16/chipmunk-blob-stable-git.tgz 722617 289c1b1ec15f4357595966ba19df64e5 30464528704e2f69b8cd95eb0dabf4c69fb3b53a chipmunk-blob-stable-git chipmunk-blob.asd
chipz http://beta.quicklisp.org/archive/chipz/2022-02-20/chipz-20220220-git.tgz 37175 b14d05a5a12c3e5cf4bf50e98c679fd7 0305f9a94d9ba92516d4552f35b7a6e15256b0a7 chipz-20220220-git chipz.asd
chirp http://beta.quicklisp.org/archive/chirp/2021-10-20/chirp-20211020-git.tgz 88205 965a8f391d8e997749257e9e80924f03 c9322faf479c1817f33bca9ae1fdab3a56530ede chirp-20211020-git chirp-core.asd chirp-dexador.asd chirp-drakma.asd chirp.asd
chrome-native-messaging http://beta.quicklisp.org/archive/chrome-native-messaging/2015-03-02/chrome-native-messaging-20150302-git.tgz 1973 3fae36a2473eb7095d50f8472d31bd6c beeb53f51396f5fd05217c00b07306835a566943 chrome-native-messaging-20150302-git chrome-native-messaging.asd
chronicity http://beta.quicklisp.org/archive/chronicity/2019-02-02/chronicity-20190202-git.tgz 30517 43ca1a6e3f5f16f3c3fa8708aa6f8abb 8d561cd975aec6eceaabd245b8fc4e26f9450081 chronicity-20190202-git chronicity-test.asd chronicity.asd
chtml-matcher http://beta.quicklisp.org/archive/chtml-matcher/2011-10-01/chtml-matcher-20111001-git.tgz 9772 b78c982a080fa6264d0524f5aabb6440 c328ea450fd88170ce98235761bcd3973ce2fc1e chtml-matcher-20111001-git chtml-matcher.asd
chunga http://beta.quicklisp.org/archive/chunga/2022-11-06/chunga-20221106-git.tgz 20910 c992ac1d4cc33c37546bf47345e11bb8 439c5e9b4ebe022e15657b3d160f1959a168df04 chunga-20221106-git chunga.asd
ci http://beta.quicklisp.org/archive/ci/2022-11-06/ci-20221106-git.tgz 21837 2d5f556bc8ff996bc9e15fc421466a9e 6ea0d27d622374beb72627c8d82853730c6a1b87 ci-20221106-git 40ants-ci-test.asd 40ants-ci.asd
ci-utils http://beta.quicklisp.org/archive/ci-utils/2022-11-06/ci-utils-20221106-git.tgz 18550 cb5f4a8997d8ca84442f4d30970390e6 56401f4a6b0510ff36b5aed32b24d0e3099cc0de ci-utils-20221106-git ci-utils-features.asd ci-utils.asd
circular-streams http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz 3335 2383f3b82fa3335d9106e1354a678db8 aaeec87552396bc112300d66e93905c546e2c0ec circular-streams-20161204-git circular-streams-test.asd circular-streams.asd
city-hash http://beta.quicklisp.org/archive/city-hash/2020-09-25/city-hash-20200925-git.tgz 33787 dd5a769949cb213dc9138e71cdf4431e 27ea6a0862e8090ebdfb73c599dffbf5c3700fb6 city-hash-20200925-git city-hash-test.asd city-hash.asd
cl+ssl http://beta.quicklisp.org/archive/cl+ssl/2022-11-06/cl+ssl-20221106-git.tgz 90880 24c52f990b4d779e5c86cd12488f35cd cee76bc99cbe27c19c3309f077307b390d23fcf6 cl+ssl-20221106-git cl+ssl.asd cl+ssl.test.asd
cl-6502 http://beta.quicklisp.org/archive/cl-6502/2021-10-20/cl-6502-20211020-git.tgz 71980 f0502522fbba255a8de5a04494265762 f55e04108665aa220401d15ec2b08b8cf6739e35 cl-6502-20211020-git cl-6502.asd
cl-abnf http://beta.quicklisp.org/archive/cl-abnf/2020-03-25/cl-abnf-20200325-git.tgz 8343 4d550c68017593ef5c5c0ef945e095e0 02ec1aaf88657f245033848b58f9b22cd51b37a5 cl-abnf-20200325-git abnf.asd
cl-abstract-classes http://beta.quicklisp.org/archive/cl-abstract-classes/2019-03-07/cl-abstract-classes-20190307-hg.tgz 4719 9f70affac8015d8fc4e29f16c642890e 9c691e814b9e541e024751edd4e3e26c87082b0b cl-abstract-classes-20190307-hg abstract-classes.asd singleton-classes.asd
cl-acronyms http://beta.quicklisp.org/archive/cl-acronyms/2015-03-02/cl-acronyms-20150302-git.tgz 927131 99e7304da8f6408227323fdab76e07db 695aaa263b152453e6f8130afb6cfcea1165a463 cl-acronyms-20150302-git cl-acronyms.asd
cl-advice http://beta.quicklisp.org/archive/cl-advice/2022-07-07/cl-advice-20220707-git.tgz 20897 3a5223c3fe0be22bab633f3bf1721482 d0c64b84b19aafde74c2b119494793226f1dc2ad cl-advice-20220707-git cl-advice-tests.asd cl-advice.asd
cl-algebraic-data-type http://beta.quicklisp.org/archive/cl-algebraic-data-type/2019-10-07/cl-algebraic-data-type-20191007-git.tgz 7396 022de40e52b252919ea9c7f77ab90435 eec9f2941bcad980c2f76a5f94df20f1f920c87f cl-algebraic-data-type-20191007-git cl-algebraic-data-type.asd
cl-all http://beta.quicklisp.org/archive/cl-all/2022-11-06/cl-all-20221106-git.tgz 5680 6e7033978bdce4b8d490b9f6bb3e8e4e a80d69fe7ef5f8a6207ab1eb138787101ca637fc cl-all-20221106-git cl-all.asd
cl-amqp http://beta.quicklisp.org/archive/cl-amqp/2019-10-08/cl-amqp-v0.4.1.tgz 58162 1867a1d1ecdf4606ed8c50d583b1b876 92e5c46f853154df29fb8e8a1a62bbbf23b34332 cl-amqp-v0.4.1 cl-amqp.asd cl-amqp.test.asd
cl-ana http://beta.quicklisp.org/archive/cl-ana/2022-07-07/cl-ana-20220707-git.tgz 599176 829cbfe76c264714cb0fe620835450fa cc2c05f00c2cef2c711ddc51ae277fef59aa7cad cl-ana-20220707-git array-utils/cl-ana.array-utils.asd binary-tree/cl-ana.binary-tree.asd calculus/cl-ana.calculus.asd cl-ana.asd clos-utils/cl-ana.clos-utils.asd columnar-table/cl-ana.columnar-table.asd csv-table/cl-ana.csv-table.asd error-propogation/cl-ana.error-propogation.asd file-utils/cl-ana.file-utils.asd fitting/cl-ana.fitting.asd functional-utils/cl-ana.functional-utils.asd generic-math/cl-ana.generic-math.asd gnuplot-interface/cl-ana.gnuplot-interface.asd gsl-cffi/cl-ana.gsl-cffi.asd hash-table-utils/cl-ana.hash-table-utils.asd hdf-cffi/cl-ana.hdf-cffi.asd hdf-table/cl-ana.hdf-table.asd hdf-typespec/cl-ana.hdf-typespec.asd hdf-utils/cl-ana.hdf-utils.asd histogram/cl-ana.histogram.asd int-char/cl-ana.int-char.asd linear-algebra/cl-ana.linear-algebra.asd list-utils/cl-ana.list-utils.asd lorentz/cl-ana.lorentz.asd macro-utils/cl-ana.macro-utils.asd makeres-block/cl-ana.makeres-block.asd makeres-branch/cl-ana.makeres-branch.asd makeres-graphviz/cl-ana.makeres-graphviz.asd makeres-macro/cl-ana.makeres-macro.asd makeres-progress/cl-ana.makeres-progress.asd makeres-table/cl-ana.makeres-table.asd makeres-utils/cl-ana.makeres-utils.asd makeres/cl-ana.makeres.asd map/cl-ana.map.asd math-functions/cl-ana.math-functions.asd memoization/cl-ana.memoization.asd ntuple-table/cl-ana.ntuple-table.asd package-utils/cl-ana.package-utils.asd pathname-utils/cl-ana.pathname-utils.asd plotting/cl-ana.plotting.asd quantity/cl-ana.quantity.asd reusable-table/cl-ana.reusable-table.asd serialization/cl-ana.serialization.asd spline/cl-ana.spline.asd statistical-learning/cl-ana.statistical-learning.asd statistics/cl-ana.statistics.asd string-utils/cl-ana.string-utils.asd symbol-utils/cl-ana.symbol-utils.asd table-utils/cl-ana.table-utils.asd table-viewing/cl-ana.table-viewing.asd table/cl-ana.table.asd tensor/cl-ana.tensor.asd typed-table/cl-ana.typed-table.asd typespec/cl-ana.typespec.asd
cl-annot http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz 10039 35d8f79311bda4dd86002d11edcd0a21 31e415954f5e033907cd5d88ee4735e4ed940f12 cl-annot-20150608-git cl-annot.asd
cl-annot-prove http://beta.quicklisp.org/archive/cl-annot-prove/2015-09-23/cl-annot-prove-20150923-git.tgz 9244 d7ee8d5c35f1aaa036b77bbd1092b77c 25a765cde6977c027de5adf3067647623e96ba05 cl-annot-prove-20150923-git cl-annot-prove-test.asd cl-annot-prove.asd
cl-annot-revisit http://beta.quicklisp.org/archive/cl-annot-revisit/2022-11-06/cl-annot-revisit-20221106-git.tgz 35123 d88a764c6faa1b7ad3251bb6e3cec8ab ea75baa9b9645609d7bac80e34e3eaf50823c60d cl-annot-revisit-20221106-git cl-annot-revisit-compat.asd cl-annot-revisit-test.asd cl-annot-revisit.asd
cl-anonfun http://beta.quicklisp.org/archive/cl-anonfun/2011-12-03/cl-anonfun-20111203-git.tgz 2163 915bda1a7653d42090f8d20a1ad85d0b a0a38ada878271e7bc8ebc9cb75a0bd7b5cc7aa5 cl-anonfun-20111203-git cl-anonfun.asd
cl-ansi-term http://beta.quicklisp.org/archive/cl-ansi-term/2021-10-20/cl-ansi-term-20211020-git.tgz 40855 0aced1136f76570831e1c239b820891c 18e4f0fc7add176f7a3e584d4cac7b7ab17716e8 cl-ansi-term-20211020-git cl-ansi-term.asd
cl-ansi-text http://beta.quicklisp.org/archive/cl-ansi-text/2021-10-20/cl-ansi-text-20211020-git.tgz 6787 5411766beeb4180218b449454b67837f 9840fc96d3395eb1cb2da6590d341ac86c4fa52d cl-ansi-text-20211020-git cl-ansi-text.asd cl-ansi-text.test.asd
cl-apertium-stream-parser http://beta.quicklisp.org/archive/cl-apertium-stream-parser/2022-03-31/cl-apertium-stream-parser-20220331-git.tgz 7302 33a86e0427fe37d2c46a4d56dbbae81e 00030654274b4c0ec453eb932e598a635fb4054b cl-apertium-stream-parser-20220331-git cl-apertium-stream.asd
cl-apple-plist http://beta.quicklisp.org/archive/cl-apple-plist/2011-11-05/cl-apple-plist-20111105-git.tgz 2720 95b6163c11c22fbb84c1f43c6703e612 b973e5c37b48d524c34b1ea2e8b89f636d69ad06 cl-apple-plist-20111105-git cl-apple-plist.asd
cl-arff-parser http://beta.quicklisp.org/archive/cl-arff-parser/2013-04-21/cl-arff-parser-20130421-git.tgz 4500 8ae977859eb11df65a1694b52436b0b5 d2342be9fa7b9a7aea26935b6268b7f556f7ff81 cl-arff-parser-20130421-git cl-arff-parser.asd
cl-argparse http://beta.quicklisp.org/archive/cl-argparse/2021-05-31/cl-argparse-20210531-git.tgz 7385 fe3efa33c6024235af44973dfb585b22 a918459cb3cee0b33fe29d189c0c4be28c38998d cl-argparse-20210531-git src/cl-argparse.asd
cl-aristid http://beta.quicklisp.org/archive/cl-aristid/2020-09-25/cl-aristid-20200925-git.tgz 4076577 472e0faacec6384973f9f5e24d78f942 127e11031f6eea32ff06fdee9f9329487095ac21 cl-aristid-20200925-git cl-aristid.asd
cl-arxiv-api http://beta.quicklisp.org/archive/cl-arxiv-api/2017-04-03/cl-arxiv-api-20170403-git.tgz 9013 3537c564323f050ba434a8198e525455 7c066716a5453b08d60181849bfb302517009806 cl-arxiv-api-20170403-git cl-arxiv-api.asd
cl-ascii-art http://beta.quicklisp.org/archive/cl-ascii-art/2017-10-19/cl-ascii-art-20171019-git.tgz 2500481 cf7fe4d84658d5d65d899e5b2c2f88fe 1fce75ccdd44c7ff91be24c51e6d570f009ccd94 cl-ascii-art-20171019-git cl-ascii-art.asd
cl-ascii-table http://beta.quicklisp.org/archive/cl-ascii-table/2020-06-10/cl-ascii-table-20200610-git.tgz 3572 6f2eaaae3fb03ba719d77ed3ffaeaf4f 4e3b075ac1131295ec488222930019dc43725617 cl-ascii-table-20200610-git cl-ascii-table.asd
cl-association-rules http://beta.quicklisp.org/archive/cl-association-rules/2017-04-03/cl-association-rules-20170403-git.tgz 4370 641b30a4fcf913cf91acbe6aaf2cae1a cf2b99cd6350ac6eef1a1301b6f80d5d27d5e305 cl-association-rules-20170403-git cl-association-rules.asd
cl-async http://beta.quicklisp.org/archive/cl-async/2022-11-06/cl-async-20221106-git.tgz 57994 c9d0db085e1b533b2b3a45dd54e4ae36 44b5e8296cc993a8d3f796d909dadd6ace6e5bd7 cl-async-20221106-git cl-async-repl.asd cl-async-ssl.asd cl-async-test.asd cl-async.asd
cl-async-await http://beta.quicklisp.org/archive/cl-async-await/2020-10-16/cl-async-await-20201016-git.tgz 14628 66d91f98068c3e9c57274f291bbf13fd 0728371bd39642b3d703378c21477c85a6bbfa4a cl-async-await-20201016-git cl-async-await.asd
cl-async-future http://beta.quicklisp.org/archive/cl-async-future/2015-01-13/cl-async-future-20150113-git.tgz 5719 961dbcb0bad3515ac7170f96dfd626ef 50751c2b573e0323f4c4687427df1d15b901cc38 cl-async-future-20150113-git cl-async-future.asd
cl-aubio http://beta.quicklisp.org/archive/cl-aubio/2020-04-27/cl-aubio-20200427-git.tgz 2886851 4125b5ea70516056040c017f9d6f5cd0 2b171fc15cf98fe4e5051370b50a1f1256f1a190 cl-aubio-20200427-git cl-aubio.asd
cl-autorepo http://beta.quicklisp.org/archive/cl-autorepo/2018-07-11/cl-autorepo-20180711-git.tgz 2223 333fc8779ce41c4e87ed5bdae6a18047 93fa8ee37a34306d513fbdcdfef0b32b6e50723d cl-autorepo-20180711-git cl-autorepo.asd
cl-autowrap http://beta.quicklisp.org/archive/cl-autowrap/2022-11-06/cl-autowrap-20221106-git.tgz 74898 9e8dd3ff69edfd16082efc353cf9f218 bb5cd1c163f526c8527d9b7c2a2505166c59bbfd cl-autowrap-20221106-git cl-autowrap-test.asd cl-autowrap.asd cl-plus-c.asd
cl-azure http://beta.quicklisp.org/archive/cl-azure/2016-08-25/cl-azure-20160825-git.tgz 16121 b85ed39bbbe3dc96b008dba7f7832365 e6bc24f54ee60ad9c51143995e36e9344f450b57 cl-azure-20160825-git cl-azure.asd
cl-base16 http://beta.quicklisp.org/archive/cl-base16/2020-09-25/cl-base16-20200925-git.tgz 15063 7f03987a109fbea2e7f28a4bf4f50ca4 1aff70774c128088935caf98ba76ed3a0c075248 cl-base16-20200925-git cl-base16.asd
cl-base32 http://beta.quicklisp.org/archive/cl-base32/2013-04-20/cl-base32-20130420-git.tgz 3417 e5066e4e4947e6f9d4debcbb38c008b9 ae9f24b9a9f4055650d2cc5aafd986cd4251b19b cl-base32-20130420-git cl-base32.asd
cl-base58 http://beta.quicklisp.org/archive/cl-base58/2015-01-13/cl-base58-20150113-git.tgz 2327 18cbd835ced24e94b0eff6380d7ee088 114d203cecd45d09c54756b5042d493c31f37d51 cl-base58-20150113-git cl-base58-test.asd cl-base58.asd
cl-base64 http://beta.quicklisp.org/archive/cl-base64/2020-10-16/cl-base64-20201016-git.tgz 10373 f556f7c61f785c84abdc1beb63c906ae f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a cl-base64-20201016-git cl-base64.asd
cl-bayesnet http://beta.quicklisp.org/archive/cl-bayesnet/2013-04-20/cl-bayesnet-20130420-git.tgz 1176067 bfbc8a2a51d5b76c4c53993d2280d94f ff6228f63582e6f4a5665fb845bce62df365347a cl-bayesnet-20130420-git cl-bayesnet.asd
cl-bcrypt http://beta.quicklisp.org/archive/cl-bcrypt/2020-09-25/cl-bcrypt-20200925-git.tgz 6939 e39524f515977708479c414e7c654246 db9b71109df120dca378e2284445aad633fbdd1f cl-bcrypt-20200925-git cl-bcrypt.asd cl-bcrypt.test.asd
cl-beanstalk http://beta.quicklisp.org/archive/cl-beanstalk/2022-07-07/cl-beanstalk-20220707-git.tgz 8830 38783b6a33a9d7686f834c5534d74b42 8505a2d7dcb085806c3d00797f2b02ec7f2af615 cl-beanstalk-20220707-git cl-beanstalk.asd
cl-bencode http://beta.quicklisp.org/archive/cl-bencode/2018-02-28/cl-bencode-20180228-git.tgz 6343 4eaa85d018a4fbb35378c07c727bf585 0548331a29e838863d1f0573ca8c788647ea8196 cl-bencode-20180228-git bencode.asd
cl-bert http://beta.quicklisp.org/archive/cl-bert/2014-11-06/cl-bert-20141106-git.tgz 3107 146379540abc497d942ef89d33df9672 d7082e37cc22c2d99b2dba50f6cf8ea1060f85a9 cl-bert-20141106-git bert.asd
cl-bibtex http://beta.quicklisp.org/archive/cl-bibtex/2018-12-10/cl-bibtex-20181210-git.tgz 76724 83cf40c69b449a4b543538f67fdf69cd 05c1cf877743b2f32a2d8f87fc871858d9b403a5 cl-bibtex-20181210-git bibtex.asd
cl-bip39 http://beta.quicklisp.org/archive/cl-bip39/2018-07-11/cl-bip39-20180711-git.tgz 10742 a791287d7b55d8a813f3239016b321ea f24dffe751c80eaa3e0042545289be79c7447be2 cl-bip39-20180711-git cl-bip39.asd
cl-bloggy http://beta.quicklisp.org/archive/cl-bloggy/2021-10-20/cl-bloggy-20211020-git.tgz 50904 b2526535b115d8c221b5c838d31ffd06 b27037d7e59cb27896e6fdf0b979a1f822b9a755 cl-bloggy-20211020-git cl-bloggy.asd
cl-bloom http://beta.quicklisp.org/archive/cl-bloom/2018-02-28/cl-bloom-20180228-git.tgz 4302 89f0727b66223ccb6aeb294fc0cc011f ad6f0142aefcc1bfbeeec81e09627a2a74e78047 cl-bloom-20180228-git cl-bloom.asd
cl-bloom-filter http://beta.quicklisp.org/archive/cl-bloom-filter/2022-11-06/cl-bloom-filter-20221106-git.tgz 4588 6a682728a968b6a4aeb0b852ef78b97d 0e7b2be8b1553ff11d0c9accbfce250fbc29513f cl-bloom-filter-20221106-git cl-bloom-filter.asd
cl-bmas http://beta.quicklisp.org/archive/cl-bmas/2022-11-06/cl-bmas-20221106-git.tgz 497282 55d3eb56231b464f3c661ba0a0e60d64 c8b6182e1a2194baa55ac76c27a5027fce367022 cl-bmas-20221106-git bmas.asd
cl-bnf http://beta.quicklisp.org/archive/cl-bnf/2020-09-25/cl-bnf-20200925-git.tgz 5695 61b1aaf5309504eb04ffdf0d0922c947 af30c5338cfc39ad06199a4b205327c53ba7d826 cl-bnf-20200925-git cl-bnf-examples.asd cl-bnf-tests.asd cl-bnf.asd
cl-bootstrap http://beta.quicklisp.org/archive/cl-bootstrap/2018-08-31/cl-bootstrap-20180831-git.tgz 161893 cee57823b000ebedbf0ca2a5bc745e8b 832338aec105f68f8982c4e6ecdc1209361ce3e8 cl-bootstrap-20180831-git cl-bootstrap-demo.asd cl-bootstrap-test.asd cl-bootstrap.asd
cl-bplustree http://beta.quicklisp.org/archive/cl-bplustree/2018-03-28/cl-bplustree-20180328-git.tgz 8921 e5a31bafa8e9e42a5da16d675b852697 84702c33e5625e787ea4df04d7d5c2cf82336bde cl-bplustree-20180328-git cl-bplustree.asd
cl-bson http://beta.quicklisp.org/archive/cl-bson/2017-04-03/cl-bson-20170403-git.tgz 35505 c9359beeeb67fde4566ca3fdcd2e7ba6 74baa529bd8c1038f4dc509baabba84f545f001f cl-bson-20170403-git cl-bson-test.asd cl-bson.asd
cl-buchberger http://beta.quicklisp.org/archive/cl-buchberger/2020-10-16/cl-buchberger-20201016-git.tgz 7929 c2c1e6f2fd6cf9c61bb2c803478c416a 8d5eef1b76316d207172e92fd4c30ff644d49586 cl-buchberger-20201016-git cl-buchberger.asd
cl-bus http://beta.quicklisp.org/archive/cl-bus/2021-12-09/cl-bus-20211209-git.tgz 2514 2c6172af8198fb4837956f40e3c702c1 e4e347ce849044de9cdf15dbbf68ba538e50aaec cl-bus-20211209-git cl-bus.asd
cl-ca http://beta.quicklisp.org/archive/cl-ca/2016-12-04/cl-ca-20161204-git.tgz 4056 e20a120a4bdea1da122f67d1c748c164 250c6a1fd47118fd4634c1ca7b67f6eec8822e29 cl-ca-20161204-git cl-ca.asd
cl-cache-tables http://beta.quicklisp.org/archive/cl-cache-tables/2017-10-19/cl-cache-tables-20171019-git.tgz 5219 24fcc0c7e5c4b56aa4d3c0ccf8013804 8467ba23db68b1b2136216eb37934664bbc56560 cl-cache-tables-20171019-git cl-cache-tables.asd
cl-cairo2 http://beta.quicklisp.org/archive/cl-cairo2/2021-10-20/cl-cairo2-20211020-git.tgz 223436 5695cf9b084f31f141a754611b54ab76 34fc6c321105781ff8edce95e921dddf81f85a40 cl-cairo2-20211020-git a-cl-cairo2-loader.asd cl-cairo2-demos.asd cl-cairo2-xlib.asd cl-cairo2.asd
cl-capstone http://beta.quicklisp.org/archive/cl-capstone/2022-03-31/cl-capstone-20220331-git.tgz 13490 ec4e4521f3b4886788b07f7668f88a80 ce108d8fb0ec89d2e08b3f388c3aa9e812751fe8 cl-capstone-20220331-git capstone.asd
cl-case-control http://beta.quicklisp.org/archive/cl-case-control/2014-11-06/cl-case-control-20141106-git.tgz 4262 9bd926eaf15cc7053ef7e6676491aa23 a2d273abfa6ff8f0680f0f9d6545064ba133908a cl-case-control-20141106-git cl-case-control.asd
cl-catmull-rom-spline http://beta.quicklisp.org/archive/cl-catmull-rom-spline/2022-02-20/cl-catmull-rom-spline-20220220-git.tgz 25468 373b0bf5ef596bd00f8755ee2bef7b07 3e3caa267dd52c682afd652d58bb6cc7ef5eb0cb cl-catmull-rom-spline-20220220-git cl-catmull-rom-spline.asd
cl-cblas http://beta.quicklisp.org/archive/cl-cblas/2022-11-06/cl-cblas-20221106-git.tgz 62256 3c517950f3e7990d06fa47dc49aa8ad0 85245e35d8177510f53b4ffc116ba938944e8bc8 cl-cblas-20221106-git cblas.asd
cl-cerf http://beta.quicklisp.org/archive/cl-cerf/2021-05-31/cl-cerf-20210531-git.tgz 1923 fc9737d516b648716dbe5fdb70938e42 2eec3e62b0bebeee2b74fc545261be8a8264eee8 cl-cerf-20210531-git cl-cerf.asd
cl-cffi-gtk http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz 6290907 954beac0970a46263153c2863ad1cb5f 0d9561465c894d6dc57a9329ff950fe07cacbd0d cl-cffi-gtk-20201220-git cairo/cl-cffi-gtk-cairo.asd demo/cairo-demo/cl-cffi-gtk-demo-cairo.asd demo/glib-demo/cl-cffi-gtk-demo-glib.asd demo/gobject-demo/cl-cffi-gtk-demo-gobject.asd demo/gtk-example/cl-cffi-gtk-example-gtk.asd demo/opengl-demo/cl-cffi-gtk-opengl-demo.asd gdk-pixbuf/cl-cffi-gtk-gdk-pixbuf.asd gdk/cl-cffi-gtk-gdk.asd gio/cl-cffi-gtk-gio.asd glib/cl-cffi-gtk-glib.asd gobject/cl-cffi-gtk-gobject.asd gtk/cl-cffi-gtk.asd pango/cl-cffi-gtk-pango.asd
cl-change-case http://beta.quicklisp.org/archive/cl-change-case/2021-04-11/cl-change-case-20210411-git.tgz 4792 df72a3d71a6c65e149704688aec859b9 d19d49e30d952a38429ac25dc2005999bcfe003c cl-change-case-20210411-git cl-change-case.asd
cl-charms http://beta.quicklisp.org/archive/cl-charms/2022-11-06/cl-charms-20221106-git.tgz 27272 9e7c2e906b93ccc30c182273ea95111a d066e06d27bfac4f8c981291eb4ee36becf0f781 cl-charms-20221106-git cl-charms-paint.asd cl-charms-timer.asd cl-charms.asd
cl-cheshire-cat http://beta.quicklisp.org/archive/cl-cheshire-cat/2012-11-25/cl-cheshire-cat-20121125-git.tgz 23482 729d03cde121deedf97f3669c262e82e d2797915bed6422d5516abeb9f3c4a33809c306b cl-cheshire-cat-20121125-git cl-cheshire-cat.asd
cl-clblas http://beta.quicklisp.org/archive/cl-clblas/2018-10-18/cl-clblas-20181018-git.tgz 8535 ae2ac2ceba89561bc472677ab373017f ecca33c74178a2f77c94fdb3f40a9fee5e87c399 cl-clblas-20181018-git cl-clblas-test.asd cl-clblas.asd
cl-cli http://beta.quicklisp.org/archive/cl-cli/2015-12-18/cl-cli-20151218-git.tgz 6467 820e5c7dde6800fcfa44b1fbc7a9d62b 95d3aaf9325b6317343844e8b40efdf7c302a47f cl-cli-20151218-git cl-cli.asd
cl-cli-parser http://beta.quicklisp.org/archive/cl-cli-parser/2015-06-08/cl-cli-parser-20150608-git.tgz 8093 38fc199ad50a98819a3cd0d82665fe68 a7e3a4d60a6069b08ecd5ebf477609c6927710c3 cl-cli-parser-20150608-git cli-parser.asd
cl-clon http://beta.quicklisp.org/archive/cl-clon/2021-04-11/clon-1.0b25.tgz 247117 ff8cb8e1a7988e4d0475a3a51e804f9e 39a0a227047d8afb94f980638e14faef500feccd clon-1.0b25 core/net.didierverna.clon.core.asd demos/advanced.asd demos/simple.asd net.didierverna.clon.asd setup/net.didierverna.clon.setup.asd
cl-closure-template http://beta.quicklisp.org/archive/cl-closure-template/2015-08-04/cl-closure-template-20150804-git.tgz 98945 d2b36fa36a3bbb532c7898c2ff6211f7 b58d01914b50c26a7a43ed1e0848562a212017b3 cl-closure-template-20150804-git closure-template.asd
cl-clsparse http://beta.quicklisp.org/archive/cl-clsparse/2019-08-13/cl-clsparse-20190813-git.tgz 5431 f52ee9a080bc55364c817ea7c032588d e9b211b3f6c39cca6e07516292673c76271b2349 cl-clsparse-20190813-git cl-clsparse.asd
cl-cognito http://beta.quicklisp.org/archive/cl-cognito/2018-12-10/cl-cognito-20181210-git.tgz 10532 6372b22b37cd2f092542cf4add7f336b a31ce281d683c6d15bd458f2dc366ea5ba641b86 cl-cognito-20181210-git cl-cognito.asd
cl-coinpayments http://beta.quicklisp.org/archive/cl-coinpayments/2021-08-07/cl-coinpayments-20210807-git.tgz 12852 31e348c2de72c1babf5ca0e557027e32 cd40b660e6f9c03b206f9270df3e8ab6137f95c2 cl-coinpayments-20210807-git cl-coinpayments.asd
cl-collider http://beta.quicklisp.org/archive/cl-collider/2022-11-06/cl-collider-20221106-git.tgz 64694 e2ffde8e1620231428bd3c78d4ad36e5 c2a1df9d8909ac7889fa1e97e7b7b00c31a29851 cl-collider-20221106-git cl-collider.asd osc/sc-osc.asd
cl-colors http://beta.quicklisp.org/archive/cl-colors/2018-03-28/cl-colors-20180328-git.tgz 14566 5e59ea59b32a0254df9610a5662ae2ec 08d7a2af682802fce159e47ff3511112f24e892a cl-colors-20180328-git cl-colors.asd
cl-colors2 http://beta.quicklisp.org/archive/cl-colors2/2021-10-20/cl-colors2-20211020-git.tgz 25522 13fd422daa03328c909d1578d65f6222 baecbcddcff7c7034c03cb6b79bd985086c8d703 cl-colors2-20211020-git cl-colors2.asd
cl-confidence http://beta.quicklisp.org/archive/cl-confidence/2022-11-06/cl-confidence-20221106-git.tgz 35507 772fa25837effcce10aa756b82eb5ff7 25f35e257faa755adf5cd38c332baa0846f4eee2 cl-confidence-20221106-git org.melusina.confidence.asd
cl-conllu http://beta.quicklisp.org/archive/cl-conllu/2021-12-09/cl-conllu-20211209-git.tgz 40657 420f86447668686ec1c3ee7c68fc610c 6c22fa31a05e26e11a2da8f3e0b834a1fca38fcd cl-conllu-20211209-git cl-conllu.asd
cl-conspack http://beta.quicklisp.org/archive/cl-conspack/2017-04-03/cl-conspack-20170403-git.tgz 46289 43b17d3d9bb969ffd1919f7c05453c14 6f2acf5bb1d4c2d18573fc5f6eec367325131924 cl-conspack-20170403-git cl-conspack-test.asd cl-conspack.asd
cl-cont http://beta.quicklisp.org/archive/cl-cont/2011-02-19/cl-cont-20110219-darcs.tgz 11715 204ad0178da3de604e92fab5ac1c20b6 f24ffb4d90a98f4ab82841279f29ac64615069de cl-cont-20110219-darcs cl-cont-test.asd cl-cont.asd
cl-containers http://beta.quicklisp.org/archive/cl-containers/2020-04-27/cl-containers-20200427-git.tgz 231463 bb0e03a581e9b617dd166a3f511eaf6a dfeb22f02e3cf62dc0767340354bb021cda4414b cl-containers-20200427-git cl-containers-test.asd cl-containers.asd
cl-cookie http://beta.quicklisp.org/archive/cl-cookie/2022-07-07/cl-cookie-20220707-git.tgz 5275 87eb880bb2cf1f7d068dace80b6dc83e c376c6cc0013aa678a2df622039eb3db77965ce4 cl-cookie-20220707-git cl-cookie-test.asd cl-cookie.asd
cl-coroutine http://beta.quicklisp.org/archive/cl-coroutine/2016-09-29/cl-coroutine-20160929-git.tgz 3335 d89c78cb0a94768603c8f581227af23f 934dcbb769a9199affe633368462e104fbf2c03f cl-coroutine-20160929-git cl-coroutine-test.asd cl-coroutine.asd
cl-coveralls http://beta.quicklisp.org/archive/cl-coveralls/2021-04-11/cl-coveralls-20210411-git.tgz 7733 6042f6fd3f0d1aff5bffb99ee72f3459 fc7fea5d98341ae5580b60f3e8baa38f093ac5e6 cl-coveralls-20210411-git cl-coveralls-test.asd cl-coveralls.asd
cl-covid19 http://beta.quicklisp.org/archive/cl-covid19/2022-03-31/cl-covid19-20220331-git.tgz 7711577 78dcd44e5033ac2cd42b6ca3d0a473ff 54bb3d49d86b349f5f6aa9dc6febd21cc84cfeb2 cl-covid19-20220331-git cl-covid19.asd
cl-cpus http://beta.quicklisp.org/archive/cl-cpus/2018-04-30/cl-cpus-20180430-git.tgz 2505 8144fd890f060d558d896c2b10538f02 1c38814243fe2a8f437189d7a7496cd51574f1bb cl-cpus-20180430-git cl-cpus.asd
cl-cram http://beta.quicklisp.org/archive/cl-cram/2022-07-07/cl-cram-20220707-git.tgz 2926 0ec0afedaba353fb426ae1ad5e93ab59 987b1c557a0c03a9009afa987a24742ab2c76f0c cl-cram-20220707-git cl-cram.asd
cl-crc64 http://beta.quicklisp.org/archive/cl-crc64/2014-07-13/cl-crc64-20140713-git.tgz 3436 d97cf9231647235a938707e64a1766ad 3140afa99b2ee11f7cda85f9563b975c45cdb9d2 cl-crc64-20140713-git cl-crc64.asd
cl-creditcard http://beta.quicklisp.org/archive/cl-creditcard/2015-01-13/cl-creditcard-20150113-git.tgz 10834 35f506d0dcef15f26a46b6419c0f060b 0b816115dbedc264e2d3724088267220a8e43a5a cl-creditcard-20150113-git cl-authorize-net.asd cl-creditcard.asd
cl-cron http://beta.quicklisp.org/archive/cl-cron/2022-11-06/cl-cron-20221106-git.tgz 16377 9e168c76735db839b1ef8ee580ac41c5 270f69db8a96ac5a91c6eedb2142d6abbf786523 cl-cron-20221106-git cl-cron.asd
cl-crypt http://beta.quicklisp.org/archive/cl-crypt/2012-05-20/cl-crypt-20120520-git.tgz 7279 0e6b5ba0cd7a565686e847197622698f f66ea06ec261e994f5ba7d71236c93a3a4edd113 cl-crypt-20120520-git crypt.asd
cl-css http://beta.quicklisp.org/archive/cl-css/2014-09-14/cl-css-20140914-git.tgz 4907 a91f5a5d6a751af31d5c4fd8170f6ece 0b25eb863296f4d83523535c606514502ad6aac5 cl-css-20140914-git cl-css.asd
cl-csv http://beta.quicklisp.org/archive/cl-csv/2020-10-16/cl-csv-20201016-git.tgz 25202 3e067784236ab620857fe738dafedb4b 50b9ecb493ce094c7eba3b9bcb6998774b06c3d6 cl-csv-20201016-git cl-csv-clsql.asd cl-csv-data-table.asd cl-csv.asd
cl-cuda http://beta.quicklisp.org/archive/cl-cuda/2021-08-07/cl-cuda-20210807-git.tgz 73706 0502aed4f738192adee742b7757ee8d7 e73574a8fd2d4e821d6831deb8c3881a228648f8 cl-cuda-20210807-git cl-cuda-examples.asd cl-cuda-interop-examples.asd cl-cuda-interop.asd cl-cuda-misc.asd cl-cuda.asd
cl-custom-hash-table http://beta.quicklisp.org/archive/cl-custom-hash-table/2020-12-20/cl-custom-hash-table-20201220-git.tgz 7660 bd0f2f4a8e808911133af19c03e5c511 0c417f960bf62104ede823c1d48c380ea03c3d58 cl-custom-hash-table-20201220-git cl-custom-hash-table-test.asd cl-custom-hash-table.asd
cl-cxx http://beta.quicklisp.org/archive/cl-cxx/2021-04-11/cl-cxx-20210411-git.tgz 6714 fe57ef065e53ba371cf9b4677c4a7993 61294f8511952da27d84b28491b5d6f5d47e9167 cl-cxx-20210411-git cxx-test.asd cxx.asd
cl-cxx-jit http://beta.quicklisp.org/archive/cl-cxx-jit/2022-03-31/cl-cxx-jit-20220331-git.tgz 1258780 3375be6d93acf2e1c7e7ba1aba3f0f26 b76ae701c8f49f7be53aa91176e48f30faef60d3 cl-cxx-jit-20220331-git cxx-jit.asd
cl-darksky http://beta.quicklisp.org/archive/cl-darksky/2018-07-11/cl-darksky-20180711-git.tgz 2006 c62b43b0d00975df19b5c5e72433b462 4b55a096708a83a7fa703813c4ddb02178e45ab3 cl-darksky-20180711-git cl-darksky-test.asd cl-darksky.asd
cl-data-format-validation http://beta.quicklisp.org/archive/cl-data-format-validation/2014-07-13/cl-data-format-validation-20140713-git.tgz 37403 2d13446e593b3b0c46fb83ee9fc5da7f 0a085113a3c0e2c28735f4709b31ff46ee54b68b cl-data-format-validation-20140713-git data-format-validation.asd
cl-data-frame http://beta.quicklisp.org/archive/cl-data-frame/2021-05-31/cl-data-frame-20210531-git.tgz 8843 1d1f7444704e6b05f7ca4e95cf3cd222 e67914091fae9be9199cc85b51275c43e82b10a9 cl-data-frame-20210531-git cl-data-frame.asd
cl-data-structures http://beta.quicklisp.org/archive/cl-data-structures/2022-11-06/cl-data-structures-20221106-git.tgz 1241278 e096e48a5644ac91485b1210aa6fa5cc 63d450d8511ea85f27e7db6ebf57d1942637e214 cl-data-structures-20221106-git cl-data-structures-tests.asd cl-data-structures.asd
cl-date-time-parser http://beta.quicklisp.org/archive/cl-date-time-parser/2014-07-13/cl-date-time-parser-20140713-git.tgz 10231 a5c384eafcdcf063499341b40c09129a 7633ae11684c9c8cd219f4cf615869bc2b5d2c42 cl-date-time-parser-20140713-git cl-date-time-parser.asd
cl-db3 http://beta.quicklisp.org/archive/cl-db3/2020-02-18/cl-db3-20200218-git.tgz 6162 42a8e17c70e8a4ded2771207546bf498 46fd1c5dff7709bd9a7fe3d8316aefc51446b2cc cl-db3-20200218-git db3.asd
cl-dbi http://beta.quicklisp.org/archive/cl-dbi/2021-10-20/cl-dbi-20211020-git.tgz 19591 565a1f32b2d924ad59876afcdc5cf263 6ccceecd1cd903d5c5acf3e6d13787ca469c25ee cl-dbi-20211020-git cl-dbi.asd dbd-mysql.asd dbd-postgres.asd dbd-sqlite3.asd dbi-test.asd dbi.asd
cl-dct http://beta.quicklisp.org/archive/cl-dct/2022-03-31/cl-dct-20220331-git.tgz 6828 3ccdd003cad721787fdfa1fca8516222 064e1eacdbce4f3a1ea7466b9ab7497b156c91ce cl-dct-20220331-git dct-test.asd dct.asd
cl-debug-print http://beta.quicklisp.org/archive/cl-debug-print/2021-08-07/cl-debug-print-20210807-git.tgz 2944 bf914351ab8d3ecc043f2772f3f659c8 4dd5eef46654f445f511e4f46627310e8dbe152d cl-debug-print-20210807-git cl-debug-print-test.asd cl-debug-print.asd cl-syntax-debug-print.asd
cl-decimals http://beta.quicklisp.org/archive/cl-decimals/2021-12-09/cl-decimals-20211209-git.tgz 8043 d545d06edcc98c0c2bd465ea1078681f c623daafd548125e0b92ed9788e4994ab55d8cc8 cl-decimals-20211209-git decimals.asd
cl-dejavu http://beta.quicklisp.org/archive/cl-dejavu/2021-01-24/cl-dejavu-20210124-git.tgz 5512426 08375ca2692adc30b20594cb91c3361e 2ea010200840ea7a82cb49619783a5be512a6533 cl-dejavu-20210124-git cl-dejavu.asd
cl-devil http://beta.quicklisp.org/archive/cl-devil/2015-03-02/cl-devil-20150302-git.tgz 7271 2386d79fa23a831b46dd3a851b635165 81f0c286536f30795267f35614562d2459c41cea cl-devil-20150302-git cl-devil.asd cl-ilu.asd cl-ilut.asd
cl-diceware http://beta.quicklisp.org/archive/cl-diceware/2015-09-23/cl-diceware-20150923-git.tgz 46217 1effc5add086f20640ecca3ea9fb6d44 26501cee6304c77b9db6320e1f2b3fbba88ede2b cl-diceware-20150923-git cl-diceware.asd
cl-difflib http://beta.quicklisp.org/archive/cl-difflib/2013-01-28/cl-difflib-20130128-git.tgz 11909 e8a3434843a368373b67d09983d2b809 2acef03b40d410454539b26882762b25f60da136 cl-difflib-20130128-git cl-difflib-tests.asd cl-difflib.asd
cl-digraph http://beta.quicklisp.org/archive/cl-digraph/2021-10-20/cl-digraph-20211020-hg.tgz 36912 737c3640b4b079ce0ee730525aa8b6de 2b4b9313c4c22b73dd4f94637c65c007c4ef576b cl-digraph-20211020-hg cl-digraph.asd cl-digraph.dot.asd cl-digraph.test.asd
cl-diskspace http://beta.quicklisp.org/archive/cl-diskspace/2022-03-31/cl-diskspace-20220331-git.tgz 4811 e0108e2388516db61506650273d570a9 2a14bde83c155dae101941a8bb65394326e4eafc cl-diskspace-20220331-git cl-diskspace.asd
cl-disque http://beta.quicklisp.org/archive/cl-disque/2017-12-27/cl-disque-20171227-git.tgz 12120 422f594efe55882f080273d68d26c561 f0a7b26834d07a6b35c03c16ba8aeeae18df6160 cl-disque-20171227-git cl-disque-test.asd cl-disque.asd
cl-djula-svg http://beta.quicklisp.org/archive/cl-djula-svg/2022-11-06/cl-djula-svg-20221106-git.tgz 3913 a3dad13ee80597292649c4d0dd577ca2 07b086e51c3cd4a5bb675aaf2e2b3892b2a6db3e cl-djula-svg-20221106-git cl-djula-svg.asd
cl-djula-tailwind http://beta.quicklisp.org/archive/cl-djula-tailwind/2022-11-06/cl-djula-tailwind-20221106-git.tgz 19195 97e86ba99d7afa52c284a14f4a56f763 087d8a078fc4bf6541e0243bfbd53c05b576e611 cl-djula-tailwind-20221106-git cl-djula-tailwind.asd
cl-docutils http://beta.quicklisp.org/archive/cl-docutils/2013-01-28/cl-docutils-20130128-git.tgz 115606 e83e70398da47984339dd29632a78072 014884afae1335295230482b54b560ed7bc51db6 cl-docutils-20130128-git docutils.asd
cl-dot http://beta.quicklisp.org/archive/cl-dot/2022-07-07/cl-dot-20220707-git.tgz 188392 185175a2da8e7ad5db5e8347c9d52016 f807802932bf6a30a2f6ff196fbe623cd67a893d cl-dot-20220707-git cl-dot.asd
cl-dotenv http://beta.quicklisp.org/archive/cl-dotenv/2018-10-18/cl-dotenv-20181018-git.tgz 5339 ea905b934f2a2dc8ee3bfc88fc35ac49 3fe52852f1350c31baa11f85094ad6b7c433ea42 cl-dotenv-20181018-git cl-dotenv-test.asd cl-dotenv.asd
cl-drawille http://beta.quicklisp.org/archive/cl-drawille/2021-08-07/cl-drawille-20210807-git.tgz 8525 105ab0a62c3f87f604e2f02ff9a761a1 5c7227a1ad1f81bcae14cb448637c601dec36f31 cl-drawille-20210807-git cl-drawille.asd
cl-drm http://beta.quicklisp.org/archive/cl-drm/2016-12-04/cl-drm-20161204-git.tgz 3310 dc45def8e5c9df2d9622193b400aa968 5f5474b54ced85e2eaba592dac37c07eb12f702c cl-drm-20161204-git cl-drm.asd
cl-dropbox http://beta.quicklisp.org/archive/cl-dropbox/2015-06-08/cl-dropbox-20150608-git.tgz 3127 cb8e142a42e59c3ad3ebc51243f0e9fd 692318495dcbb349116b544b33482119a1620ff7 cl-dropbox-20150608-git cl-dropbox.asd
cl-dsl http://beta.quicklisp.org/archive/cl-dsl/2013-07-20/cl-dsl-20130720-git.tgz 14073 fce58e9d8682e3224120cc794922de84 a93b21d4833d1d92609d2399028cbba3e908cbbf cl-dsl-20130720-git cl-dsl.asd
cl-durian http://beta.quicklisp.org/archive/cl-durian/2015-06-08/cl-durian-20150608-git.tgz 4819 9da8dd551e1ee63907a79bea0b1565d3 a0ca0ed4bf0257b86270d66bda9a963d0d30529b cl-durian-20150608-git cl-durian.asd
cl-earley-parser http://beta.quicklisp.org/archive/cl-earley-parser/2021-10-20/cl-earley-parser-20211020-git.tgz 6928 d8108fb9fb213e6e434b35e7b9c2e10a edb14920bbe5cc2cfbf7b58ca45bce1643945e85 cl-earley-parser-20211020-git cl-earley-parser.asd
cl-ecma-48 http://beta.quicklisp.org/archive/cl-ecma-48/2020-02-18/cl-ecma-48-20200218-http.tgz 22774 56ae2f232dd645265277ab2d7efbe6be 1e278da3a619022949333d7612ddcbdef11a507e cl-ecma-48-20200218-http cl-ecma-48.asd
cl-editdistance http://beta.quicklisp.org/archive/cl-editdistance/2022-03-31/cl-editdistance-20220331-git.tgz 11140 39bf900301a44e3ae6a4151ab2583d89 12cbec9df26ceb3f02f6e456fa355ec37e481ae5 cl-editdistance-20220331-git edit-distance-test.asd edit-distance.asd
cl-egl http://beta.quicklisp.org/archive/cl-egl/2019-05-21/cl-egl-20190521-git.tgz 3064 022f1ac3d01a265e700d0aa99ff47d71 03446e74bcaa71e61d1f0e9352c9df99ad3ad403 cl-egl-20190521-git cl-egl.asd
cl-elastic http://beta.quicklisp.org/archive/cl-elastic/2020-02-18/cl-elastic-20200218-git.tgz 5458 f43f47ae74b7710cb82d0da99188911f 4f3a41888a760f6964be8c7aa2a38738a7bffdcd cl-elastic-20200218-git cl-elastic-test.asd cl-elastic.asd
cl-emacs-if http://beta.quicklisp.org/archive/cl-emacs-if/2012-03-05/cl-emacs-if-20120305-git.tgz 5080 79a7e7ed0dce7b6b937481da97bc5490 3328115dfa0afe358d2301ce9d0335fb323b7b3f cl-emacs-if-20120305-git cl-emacs-if.asd
cl-emb http://beta.quicklisp.org/archive/cl-emb/2019-05-21/cl-emb-20190521-git.tgz 14557 b27bbe8de2206ab7c461700b58d4d527 04a32481580be674abe707cdfd25f20ff710ac7a cl-emb-20190521-git cl-emb.asd
cl-emoji http://beta.quicklisp.org/archive/cl-emoji/2020-02-18/cl-emoji-20200218-git.tgz 130250 62689fcd13290ef045ab41dff55882b3 45728356401d4dbcc426527cd0278d6a8d93bf9f cl-emoji-20200218-git cl-emoji-test.asd cl-emoji.asd
cl-enchant http://beta.quicklisp.org/archive/cl-enchant/2021-12-09/cl-enchant-20211209-git.tgz 7291 c12162b3a7c383815ff77c96aca0c11f ac71e6ec6e3396597c26b0757286c34b02399d8c cl-enchant-20211209-git enchant-autoload.asd enchant.asd
cl-enumeration http://beta.quicklisp.org/archive/cl-enumeration/2021-12-30/cl-enumeration-20211230-git.tgz 116097 07969d7f7dc4f03072e2ad4e5b6f1401 dafd7c3f51235618457a048bc87ae3f773eca2a1 cl-enumeration-20211230-git enumerations.asd
cl-env http://beta.quicklisp.org/archive/cl-env/2018-04-30/cl-env-20180430-git.tgz 2808 881867f2aee6a8f22acb2dc1db3b5a62 d79b84e8739451c189fa50a6df245db1d4dd0953 cl-env-20180430-git cl-env.asd
cl-environments http://beta.quicklisp.org/archive/cl-environments/2021-10-20/cl-environments-20211020-git.tgz 47800 a796decf21a5b595ff591ffca378994a 100ffebab3bc66bb81349b22ac7b286736bc7b74 cl-environments-20211020-git cl-environments.asd
cl-epmd http://beta.quicklisp.org/archive/cl-epmd/2014-02-11/cl-epmd-20140211-git.tgz 8497 535d47c3fdcbf90656549f48da838151 1e5e823a18ae86b707ebfae97acd4af7a31ef36e cl-epmd-20140211-git epmd-test.asd epmd.asd
cl-epoch http://beta.quicklisp.org/archive/cl-epoch/2018-12-10/cl-epoch-20181210-git.tgz 772 677d6391a0c4ae9b20e4115cb0681706 3266833985cfc3447642de88f2b808fd0e25d222 cl-epoch-20181210-git cl-epoch.asd
cl-erlang-term http://beta.quicklisp.org/archive/cl-erlang-term/2022-02-20/cl-erlang-term-20220220-git.tgz 18631 d59493f796dc4d7800bfc7e357b66649 045fe1ca2c2b9d3c269bbffb5a4c860058909cc2 cl-erlang-term-20220220-git erlang-term-test.asd erlang-term.asd
cl-etcd http://beta.quicklisp.org/archive/cl-etcd/2022-07-07/cl-etcd-20220707-git.tgz 18727 d4448c58805e7b31a6444e07b6236849 7b631250d7f37bba6d0294ea441d03447366aecf cl-etcd-20220707-git cl-etcd.asd test/etcd-test.asd
cl-ev http://beta.quicklisp.org/archive/cl-ev/2015-09-23/cl-ev-20150923-git.tgz 6322 802c3966a9dbd25d22407825271e70fd d90c2e7c18e3710e25ecd2206430926dc4307891 cl-ev-20150923-git ev.asd
cl-events http://beta.quicklisp.org/archive/cl-events/2016-03-18/cl-events-20160318-git.tgz 7199 064df9efa3a6db5b1540d61a91671ca8 21f4cb9f76b3ffd12d7b6d5d17e0960cd8b57819 cl-events-20160318-git cl-events.asd cl-events.test.asd
cl-ewkb http://beta.quicklisp.org/archive/cl-ewkb/2011-06-19/cl-ewkb-20110619-git.tgz 9929 cbcc96a62750e5aee99f2261d4b2171c 262f1978c053c76a4fa288411f8fbd150d29fcbb cl-ewkb-20110619-git cl-ewkb.asd
cl-factoring http://beta.quicklisp.org/archive/cl-factoring/2022-11-06/cl-factoring-20221106-git.tgz 22749 10c430bffa1bb1feb9d382492ba18b94 773a33d4c38725d5eb0282dc64e2c880c48c38a5 cl-factoring-20221106-git cl-factoring.asd
cl-facts http://beta.quicklisp.org/archive/cl-facts/2022-11-06/cl-facts-20221106-git.tgz 47137472 7a117d020ad3c478d4e20cf8df49a1cd a76ed6e533896b75257787543fb9e325e89dcd55 cl-facts-20221106-git facts.asd
cl-fad http://beta.quicklisp.org/archive/cl-fad/2022-02-20/cl-fad-20220220-git.tgz 25285 5caa98f5badf1d84ae385a3937ee2e01 27b33b1f84fa87e34ec852d3a30903106863844a cl-fad-20220220-git cl-fad.asd
cl-fam http://beta.quicklisp.org/archive/cl-fam/2012-11-25/cl-fam-20121125-git.tgz 8597 4844d1092223363858a0963b56b09d10 9def84e89f75f5d2449f31db352fc1d6d51c156a cl-fam-20121125-git cl-fam.asd
cl-fastcgi http://beta.quicklisp.org/archive/cl-fastcgi/2021-01-24/cl-fastcgi-20210124-git.tgz 4536 e4339af9b66e7d2503b9ddd3b0d2d83b 5e26a1b4849db423804da361e2074440b128a7b9 cl-fastcgi-20210124-git cl-fastcgi.asd
cl-fbclient http://beta.quicklisp.org/archive/cl-fbclient/2014-01-13/cl-fbclient-20140113-git.tgz 9685 48d0afd4a519cac7c0b219063d51f6d9 09f3e78c416b6524ebe3c2d75e279eeda08b2277 cl-fbclient-20140113-git cl-fbclient.asd
cl-feedparser http://beta.quicklisp.org/archive/cl-feedparser/2021-10-20/cl-feedparser-20211020-git.tgz 1144177 d2297b5d48656ee0807575628d615d6b ccece16e6ca4b553ce6425e08a33c2ed5c511a1d cl-feedparser-20211020-git cl-feedparser.asd test/cl-feedparser-tests.asd
cl-fix http://beta.quicklisp.org/archive/cl-fix/2022-02-20/cl-fix-20220220-git.tgz 135643 483319c13dc827257c74a02823d0efbc af3c433705257db9f5c2fe63c3f6bdd8f31f94f9 cl-fix-20220220-git cl-fix.asd
cl-fixtures http://beta.quicklisp.org/archive/cl-fixtures/2020-03-25/cl-fixtures-20200325-git.tgz 14909 0cc96fe9bc78cf66a30f3d93b00a0741 f6f5929b83592b29e2001fe95b444315401bb79b cl-fixtures-20200325-git cl-fixtures-test.asd cl-fixtures.asd
cl-flac http://beta.quicklisp.org/archive/cl-flac/2019-07-10/cl-flac-20190710-git.tgz 290402 a987ae59d6785b72735a7a102cbc9907 399983a24191cc0bc3e9657d3b4ba3bb0c9d6142 cl-flac-20190710-git cl-flac.asd
cl-flat-tree http://beta.quicklisp.org/archive/cl-flat-tree/2019-08-13/cl-flat-tree-20190813-git.tgz 5132 8705ad941f264bdedb08e4a1ad6afcfb 3f0fb91a38e4246e34d9a76d4c1dddb4515063b5 cl-flat-tree-20190813-git flat-tree.asd
cl-flow http://beta.quicklisp.org/archive/cl-flow/2022-07-07/cl-flow-stable-git.tgz 7297 a7327a90e7ed318dacd05f4e088666f8 a460a382619e0a1ce0257aa6bb79db0290c34e7d cl-flow-stable-git cl-flow.asd
cl-flowd http://beta.quicklisp.org/archive/cl-flowd/2014-07-13/cl-flowd-20140713-git.tgz 5753 c8ec0147510ab231d0e3377beaf5f897 b5382880a7203fb47f6d55b6b587a5645eb2322e cl-flowd-20140713-git cl-flowd.asd
cl-fluent-logger http://beta.quicklisp.org/archive/cl-fluent-logger/2021-10-20/cl-fluent-logger-20211020-git.tgz 4724 19d236e9b972828f26d84f0aa4f053bf 4c8b44df1de4e803896bdfe72c55b3f5995738de cl-fluent-logger-20211020-git cl-fluent-logger.asd
cl-fluidinfo http://beta.quicklisp.org/archive/cl-fluidinfo/2013-03-12/cl-fluidinfo-20130312-git.tgz 8963 31baff1a738ad8dcf30b4f466d71366c 0c8485eba076578d271d6190ba75dd853ad5867c cl-fluidinfo-20130312-git cl-fluiddb-test.asd cl-fluiddb.asd cl-fluidinfo.asd
cl-fond http://beta.quicklisp.org/archive/cl-fond/2019-11-30/cl-fond-20191130-git.tgz 328112 15c6094682447b9bc49bfa253a064360 df52e6e1d9515e749da9cca6ee1e54d378153ea3 cl-fond-20191130-git cl-fond.asd
cl-form-types http://beta.quicklisp.org/archive/cl-form-types/2022-11-06/cl-form-types-20221106-git.tgz 32266 73a0defc9bb936037b89908e44cf09f8 52210f7df7e5761c1428673760feaa925e4c71a6 cl-form-types-20221106-git cl-form-types.asd
cl-forms http://beta.quicklisp.org/archive/cl-forms/2022-11-06/cl-forms-20221106-git.tgz 1103158 a0d3a715edf91ed8bd94bff1583dca14 b5825289e17f763a30bf3506db823b2b8ad7a608 cl-forms-20221106-git cl-forms.asd cl-forms.demo.asd cl-forms.djula.asd cl-forms.peppol.asd cl-forms.test.asd cl-forms.who.asd cl-forms.who.bootstrap.asd
cl-freeimage http://beta.quicklisp.org/archive/cl-freeimage/2017-04-03/cl-freeimage-20170403-git.tgz 10611 92c8fff7a488a73ff5793f43145cb641 ca94e56e0a67d03b054160c6a78c705b0172f14d cl-freeimage-20170403-git cl-freeimage.asd
cl-freetype2 http://beta.quicklisp.org/archive/cl-freetype2/2022-07-07/cl-freetype2-20220707-git.tgz 43380 4d079ca84ed1ec0cfdc82ef577b4db0c 0f77662025e1e11e95ece1c01c71027919332dfb cl-freetype2-20220707-git cl-freetype2-tests.asd cl-freetype2.asd
cl-fsnotify http://beta.quicklisp.org/archive/cl-fsnotify/2015-03-02/cl-fsnotify-20150302-git.tgz 5979 54fe23d75d2baa6f404aef9c4da39449 6a6f82a1fc13f6286e1e9ae071e4a827830192d4 cl-fsnotify-20150302-git cl-fsnotify.asd
cl-ftp http://beta.quicklisp.org/archive/cl-ftp/2015-06-08/cl-ftp-20150608-http.tgz 9367 0743157a9fe2eea7c4a3a79874df1d55 e2ffb352da8b73a6895499ab6a1c1004e8bc5198 cl-ftp-20150608-http cl-ftp.asd ftp.asd
cl-fuse http://beta.quicklisp.org/archive/cl-fuse/2020-09-25/cl-fuse-20200925-git.tgz 23682 0342ea914801f40d804629170a435e54 b0fa74fa7c0b78e39aae5161a32abe003e5b2b4e cl-fuse-20200925-git cl-fuse.asd
cl-fuse-meta-fs http://beta.quicklisp.org/archive/cl-fuse-meta-fs/2019-07-10/cl-fuse-meta-fs-20190710-git.tgz 16844 461f7023274fb273e6c759e881bdd636 ab7279115b939e7a1d701d8d74538109313db2dc cl-fuse-meta-fs-20190710-git cl-fuse-meta-fs.asd
cl-fuzz http://beta.quicklisp.org/archive/cl-fuzz/2018-10-18/cl-fuzz-20181018-git.tgz 4141 22e715b370ea886bbff1e09db20c4e32 bd6ff387648fcf0c47266b2be40c7214b6e84bb3 cl-fuzz-20181018-git cl-fuzz.asd
cl-fxml http://beta.quicklisp.org/archive/cl-fxml/2022-03-31/cl-fxml-20220331-git.tgz 4323 41c5406bcdd73e74e9118487765e0852 32d68d36b43491d8b77d1d6236b91cf4136dbbc5 cl-fxml-20220331-git cl-fxml.asd
cl-gamepad http://beta.quicklisp.org/archive/cl-gamepad/2022-11-06/cl-gamepad-20221106-git.tgz 53179 25be4d655d3d58f79743a36c4fec256d b7db244daf5b152af929d1a6116c07ca112bb3ea cl-gamepad-20221106-git cl-gamepad.asd
cl-gap-buffer http://beta.quicklisp.org/archive/cl-gap-buffer/2019-03-07/cl-gap-buffer-20190307-hg.tgz 4587 48de07c260d666659464734743de3646 05aa46f3548f072197a6e75c075b1b8ae60d15f7 cl-gap-buffer-20190307-hg cl-gap-buffer.asd
cl-gbm http://beta.quicklisp.org/archive/cl-gbm/2018-04-30/cl-gbm-20180430-git.tgz 2187 d5f7e5c5d37248986d4a882b44ac43a9 b504515681fb74f54f2e0c3dd4e05226a72ae03c cl-gbm-20180430-git cl-gbm.asd
cl-gcrypt http://beta.quicklisp.org/archive/cl-gcrypt/2021-12-09/cl-gcrypt-20211209-git.tgz 32846 fc5b2ce86bf8f759fef46e53fc8b8c52 c0cf80a69bd8a85ef4de9b9e68b610891c03925a cl-gcrypt-20211209-git cl-gcrypt-test.asd cl-gcrypt.asd
cl-gd http://beta.quicklisp.org/archive/cl-gd/2020-12-20/cl-gd-20201220-git.tgz 202126 647e64e38d0f0ee3979e19dcb821d011 ce3c9f685fe2790f3a214380f857b2e72967d512 cl-gd-20201220-git cl-gd-test.asd cl-gd.asd
cl-gdata http://beta.quicklisp.org/archive/cl-gdata/2017-11-30/cl-gdata-20171130-git.tgz 31765 94763ae151858d354d5e9d8af3bdc538 cbcb9f87b27846e757bf70cf5cea38394ec414d4 cl-gdata-20171130-git cl-gdata.asd
cl-gearman http://beta.quicklisp.org/archive/cl-gearman/2021-10-20/cl-gearman-20211020-git.tgz 8591 e484c2d2341a2e60205aab623af4dbcf e56570929b5f2eaee67a0f44b823e14a39638a74 cl-gearman-20211020-git cl-gearman-test.asd cl-gearman.asd
cl-gendoc http://beta.quicklisp.org/archive/cl-gendoc/2018-08-31/cl-gendoc-20180831-git.tgz 6187 f74903585bca304a72b9739261c5c980 c0b1fec403200e417008b960c5ddbb6bb6bc9f53 cl-gendoc-20180831-git cl-gendoc.asd
cl-gene-searcher http://beta.quicklisp.org/archive/cl-gene-searcher/2011-10-01/cl-gene-searcher-20111001-git.tgz 3309 1350073f7965574a146421e59533bb00 35abc2a2a5b5091f0bb821269bfc6980260ed1fa cl-gene-searcher-20111001-git cl-gene-searcher.asd
cl-general-accumulator http://beta.quicklisp.org/archive/cl-general-accumulator/2021-12-09/cl-general-accumulator-20211209-git.tgz 5359 021858f3e5e4ddce93b6f4b041a3359f 497efa78b935524304ccb66f5442eb2a7b3618a7 cl-general-accumulator-20211209-git general-accumulator.asd
cl-generator http://beta.quicklisp.org/archive/cl-generator/2022-11-06/cl-generator-20221106-git.tgz 4215 2bb80e518276f716caa085f45824149a 7c9878e45b290db148da677aa121dc70a7c1f698 cl-generator-20221106-git cl-generator-test.asd cl-generator.asd
cl-geocode http://beta.quicklisp.org/archive/cl-geocode/2019-08-13/cl-geocode-20190813-git.tgz 583489 9c5dea4fa9d4d25ecb5a12d58ca518d3 a6b99dd47185ed88a289271cc668ba1c6d5a9961 cl-geocode-20190813-git cl-geocode.asd
cl-geoip http://beta.quicklisp.org/archive/cl-geoip/2013-06-15/cl-geoip-20130615-git.tgz 1698 2d174e9d08cead4ae9a320273c332844 08916ca6c4253b06adce2a03210916935d88e797 cl-geoip-20130615-git cl-geoip.asd
cl-geometry http://beta.quicklisp.org/archive/cl-geometry/2016-05-31/cl-geometry-20160531-git.tgz 17003 c0aaccbb4e2df6c504e6c1cd15155353 940f33dadfdfc8be044a94b0166ad99b29893865 cl-geometry-20160531-git cl-geometry-tests.asd cl-geometry.asd
cl-geos http://beta.quicklisp.org/archive/cl-geos/2018-07-11/cl-geos-20180711-git.tgz 18007 087b13649ed86240dead36394b5fea89 a32b0710b2ab3febb1af0fccec6a9e294675abb3 cl-geos-20180711-git cl-geos.asd
cl-getopt http://beta.quicklisp.org/archive/cl-getopt/2021-12-09/cl-getopt-20211209-git.tgz 4596 536c66692013c587940270362a09f611 c6a7d761a15fa9332f500d987444d6d0c8e6c0d5 cl-getopt-20211209-git cl-getopt.asd
cl-getx http://beta.quicklisp.org/archive/cl-getx/2020-09-25/cl-getx-20200925-git.tgz 5801 5998519d91d569c66588020035ac78bf bedde1af62586c52a0bc955cffe15df31e6a061a cl-getx-20200925-git cl-getx.asd
cl-gimei http://beta.quicklisp.org/archive/cl-gimei/2021-10-20/cl-gimei-20211020-git.tgz 149064 20080ba9a58221b02c5f2de647c4bbba e1115122633adac652992deb4777015ed62f9444 cl-gimei-20211020-git cl-gimei.asd
cl-gists http://beta.quicklisp.org/archive/cl-gists/2018-02-28/cl-gists-20180228-git.tgz 10807 adbd22dbdccd05776ad5589add0983b8 1d8c375299852e4a7de3e5495eaa066147cb445d cl-gists-20180228-git cl-gists-test.asd cl-gists.asd
cl-git http://beta.quicklisp.org/archive/cl-git/2022-11-06/cl-git-20221106-git.tgz 72466 6e08fe8d12b34952c02acaf941bdddd8 3f493ffa868e8295c6c25af613bc9e9f2d37d205 cl-git-20221106-git cl-git.asd
cl-github-v3 http://beta.quicklisp.org/archive/cl-github-v3/2019-12-27/cl-github-v3-20191227-git.tgz 2857 e116ddd20a76120573acfe6583c24cb3 353704ab1cf6849d9e4a12e9e0f4dfb9c99d2135 cl-github-v3-20191227-git cl-github-v3.asd
cl-glfw http://beta.quicklisp.org/archive/cl-glfw/2015-03-02/cl-glfw-20150302-git.tgz 461048 c939bd97538b254d445f4b0904bbb8fa 03b779d59b8807cc72bdc2a5d407a393f24fa7fd cl-glfw-20150302-git cl-glfw-ftgl.asd cl-glfw-glu.asd cl-glfw-opengl-core.asd cl-glfw-opengl-version_1_0.asd cl-glfw-opengl-version_1_1.asd cl-glfw-opengl-version_1_2.asd cl-glfw-opengl-version_1_3.asd cl-glfw-opengl-version_1_4.asd cl-glfw-opengl-version_1_5.asd cl-glfw-opengl-version_2_0.asd cl-glfw-opengl-version_2_1.asd cl-glfw-types.asd cl-glfw.asd lib/cl-glfw-opengl-3dfx_multisample.asd lib/cl-glfw-opengl-3dfx_tbuffer.asd lib/cl-glfw-opengl-3dfx_texture_compression_fxt1.asd lib/cl-glfw-opengl-amd_blend_minmax_factor.asd lib/cl-glfw-opengl-amd_depth_clamp_separate.asd lib/cl-glfw-opengl-amd_draw_buffers_blend.asd lib/cl-glfw-opengl-amd_multi_draw_indirect.asd lib/cl-glfw-opengl-amd_name_gen_delete.asd lib/cl-glfw-opengl-amd_performance_monitor.asd lib/cl-glfw-opengl-amd_sample_positions.asd lib/cl-glfw-opengl-amd_seamless_cubemap_per_texture.asd lib/cl-glfw-opengl-amd_vertex_shader_tesselator.asd lib/cl-glfw-opengl-apple_aux_depth_stencil.asd lib/cl-glfw-opengl-apple_client_storage.asd lib/cl-glfw-opengl-apple_element_array.asd lib/cl-glfw-opengl-apple_fence.asd lib/cl-glfw-opengl-apple_float_pixels.asd lib/cl-glfw-opengl-apple_flush_buffer_range.asd lib/cl-glfw-opengl-apple_object_purgeable.asd lib/cl-glfw-opengl-apple_rgb_422.asd lib/cl-glfw-opengl-apple_row_bytes.asd lib/cl-glfw-opengl-apple_specular_vector.asd lib/cl-glfw-opengl-apple_texture_range.asd lib/cl-glfw-opengl-apple_transform_hint.asd lib/cl-glfw-opengl-apple_vertex_array_object.asd lib/cl-glfw-opengl-apple_vertex_array_range.asd lib/cl-glfw-opengl-apple_vertex_program_evaluators.asd lib/cl-glfw-opengl-apple_ycbcr_422.asd lib/cl-glfw-opengl-arb_blend_func_extended.asd lib/cl-glfw-opengl-arb_color_buffer_float.asd lib/cl-glfw-opengl-arb_copy_buffer.asd lib/cl-glfw-opengl-arb_depth_buffer_float.asd lib/cl-glfw-opengl-arb_depth_clamp.asd lib/cl-glfw-opengl-arb_depth_texture.asd lib/cl-glfw-opengl-arb_draw_buffers.asd lib/cl-glfw-opengl-arb_draw_buffers_blend.asd lib/cl-glfw-opengl-arb_draw_elements_base_vertex.asd lib/cl-glfw-opengl-arb_draw_indirect.asd lib/cl-glfw-opengl-arb_draw_instanced.asd lib/cl-glfw-opengl-arb_es2_compatibility.asd lib/cl-glfw-opengl-arb_fragment_program.asd lib/cl-glfw-opengl-arb_fragment_shader.asd lib/cl-glfw-opengl-arb_framebuffer_object.asd lib/cl-glfw-opengl-arb_framebuffer_object_deprecated.asd lib/cl-glfw-opengl-arb_framebuffer_srgb.asd lib/cl-glfw-opengl-arb_geometry_shader4.asd lib/cl-glfw-opengl-arb_get_program_binary.asd lib/cl-glfw-opengl-arb_gpu_shader5.asd lib/cl-glfw-opengl-arb_gpu_shader_fp64.asd lib/cl-glfw-opengl-arb_half_float_pixel.asd lib/cl-glfw-opengl-arb_half_float_vertex.asd lib/cl-glfw-opengl-arb_imaging.asd lib/cl-glfw-opengl-arb_imaging_deprecated.asd lib/cl-glfw-opengl-arb_instanced_arrays.asd lib/cl-glfw-opengl-arb_map_buffer_range.asd lib/cl-glfw-opengl-arb_matrix_palette.asd lib/cl-glfw-opengl-arb_multisample.asd lib/cl-glfw-opengl-arb_multitexture.asd lib/cl-glfw-opengl-arb_occlusion_query.asd lib/cl-glfw-opengl-arb_occlusion_query2.asd lib/cl-glfw-opengl-arb_pixel_buffer_object.asd lib/cl-glfw-opengl-arb_point_parameters.asd lib/cl-glfw-opengl-arb_point_sprite.asd lib/cl-glfw-opengl-arb_provoking_vertex.asd lib/cl-glfw-opengl-arb_robustness.asd lib/cl-glfw-opengl-arb_sample_shading.asd lib/cl-glfw-opengl-arb_sampler_objects.asd lib/cl-glfw-opengl-arb_seamless_cube_map.asd lib/cl-glfw-opengl-arb_separate_shader_objects.asd lib/cl-glfw-opengl-arb_shader_objects.asd lib/cl-glfw-opengl-arb_shader_subroutine.asd lib/cl-glfw-opengl-arb_shading_language_100.asd lib/cl-glfw-opengl-arb_shading_language_include.asd lib/cl-glfw-opengl-arb_shadow.asd lib/cl-glfw-opengl-arb_shadow_ambient.asd lib/cl-glfw-opengl-arb_tessellation_shader.asd lib/cl-glfw-opengl-arb_texture_border_clamp.asd lib/cl-glfw-opengl-arb_texture_buffer_object.asd lib/cl-glfw-opengl-arb_texture_buffer_object_rgb32.asd lib/cl-glfw-opengl-arb_texture_compression.asd lib/cl-glfw-opengl-arb_texture_compression_bptc.asd lib/cl-glfw-opengl-arb_texture_compression_rgtc.asd lib/cl-glfw-opengl-arb_texture_cube_map.asd lib/cl-glfw-opengl-arb_texture_cube_map_array.asd lib/cl-glfw-opengl-arb_texture_env_combine.asd lib/cl-glfw-opengl-arb_texture_env_dot3.asd lib/cl-glfw-opengl-arb_texture_float.asd lib/cl-glfw-opengl-arb_texture_gather.asd lib/cl-glfw-opengl-arb_texture_mirrored_repeat.asd lib/cl-glfw-opengl-arb_texture_multisample.asd lib/cl-glfw-opengl-arb_texture_rectangle.asd lib/cl-glfw-opengl-arb_texture_rg.asd lib/cl-glfw-opengl-arb_texture_rgb10_a2ui.asd lib/cl-glfw-opengl-arb_texture_swizzle.asd lib/cl-glfw-opengl-arb_timer_query.asd lib/cl-glfw-opengl-arb_transform_feedback2.asd lib/cl-glfw-opengl-arb_transpose_matrix.asd lib/cl-glfw-opengl-arb_uniform_buffer_object.asd lib/cl-glfw-opengl-arb_vertex_array_bgra.asd lib/cl-glfw-opengl-arb_vertex_array_object.asd lib/cl-glfw-opengl-arb_vertex_attrib_64bit.asd lib/cl-glfw-opengl-arb_vertex_blend.asd lib/cl-glfw-opengl-arb_vertex_buffer_object.asd lib/cl-glfw-opengl-arb_vertex_program.asd lib/cl-glfw-opengl-arb_vertex_shader.asd lib/cl-glfw-opengl-arb_vertex_type_2_10_10_10_rev.asd lib/cl-glfw-opengl-arb_viewport_array.asd lib/cl-glfw-opengl-arb_window_pos.asd lib/cl-glfw-opengl-ati_draw_buffers.asd lib/cl-glfw-opengl-ati_element_array.asd lib/cl-glfw-opengl-ati_envmap_bumpmap.asd lib/cl-glfw-opengl-ati_fragment_shader.asd lib/cl-glfw-opengl-ati_map_object_buffer.asd lib/cl-glfw-opengl-ati_meminfo.asd lib/cl-glfw-opengl-ati_pixel_format_float.asd lib/cl-glfw-opengl-ati_pn_triangles.asd lib/cl-glfw-opengl-ati_separate_stencil.asd lib/cl-glfw-opengl-ati_text_fragment_shader.asd lib/cl-glfw-opengl-ati_texture_env_combine3.asd lib/cl-glfw-opengl-ati_texture_float.asd lib/cl-glfw-opengl-ati_texture_mirror_once.asd lib/cl-glfw-opengl-ati_vertex_array_object.asd lib/cl-glfw-opengl-ati_vertex_attrib_array_object.asd lib/cl-glfw-opengl-ati_vertex_streams.asd lib/cl-glfw-opengl-ext_422_pixels.asd lib/cl-glfw-opengl-ext_abgr.asd lib/cl-glfw-opengl-ext_bgra.asd lib/cl-glfw-opengl-ext_bindable_uniform.asd lib/cl-glfw-opengl-ext_blend_color.asd lib/cl-glfw-opengl-ext_blend_equation_separate.asd lib/cl-glfw-opengl-ext_blend_func_separate.asd lib/cl-glfw-opengl-ext_blend_minmax.asd lib/cl-glfw-opengl-ext_blend_subtract.asd lib/cl-glfw-opengl-ext_clip_volume_hint.asd lib/cl-glfw-opengl-ext_cmyka.asd lib/cl-glfw-opengl-ext_color_subtable.asd lib/cl-glfw-opengl-ext_compiled_vertex_array.asd lib/cl-glfw-opengl-ext_convolution.asd lib/cl-glfw-opengl-ext_coordinate_frame.asd lib/cl-glfw-opengl-ext_copy_texture.asd lib/cl-glfw-opengl-ext_cull_vertex.asd lib/cl-glfw-opengl-ext_depth_bounds_test.asd lib/cl-glfw-opengl-ext_direct_state_access.asd lib/cl-glfw-opengl-ext_draw_buffers2.asd lib/cl-glfw-opengl-ext_draw_instanced.asd lib/cl-glfw-opengl-ext_draw_range_elements.asd lib/cl-glfw-opengl-ext_fog_coord.asd lib/cl-glfw-opengl-ext_framebuffer_blit.asd lib/cl-glfw-opengl-ext_framebuffer_multisample.asd lib/cl-glfw-opengl-ext_framebuffer_object.asd lib/cl-glfw-opengl-ext_framebuffer_srgb.asd lib/cl-glfw-opengl-ext_geometry_shader4.asd lib/cl-glfw-opengl-ext_gpu_program_parameters.asd lib/cl-glfw-opengl-ext_gpu_shader4.asd lib/cl-glfw-opengl-ext_histogram.asd lib/cl-glfw-opengl-ext_index_array_formats.asd lib/cl-glfw-opengl-ext_index_func.asd lib/cl-glfw-opengl-ext_index_material.asd lib/cl-glfw-opengl-ext_light_texture.asd lib/cl-glfw-opengl-ext_multi_draw_arrays.asd lib/cl-glfw-opengl-ext_multisample.asd lib/cl-glfw-opengl-ext_packed_depth_stencil.asd lib/cl-glfw-opengl-ext_packed_float.asd lib/cl-glfw-opengl-ext_packed_pixels.asd lib/cl-glfw-opengl-ext_paletted_texture.asd lib/cl-glfw-opengl-ext_pixel_buffer_object.asd lib/cl-glfw-opengl-ext_pixel_transform.asd lib/cl-glfw-opengl-ext_point_parameters.asd lib/cl-glfw-opengl-ext_polygon_offset.asd lib/cl-glfw-opengl-ext_provoking_vertex.asd lib/cl-glfw-opengl-ext_secondary_color.asd lib/cl-glfw-opengl-ext_separate_shader_objects.asd lib/cl-glfw-opengl-ext_separate_specular_color.asd lib/cl-glfw-opengl-ext_shader_image_load_store.asd lib/cl-glfw-opengl-ext_stencil_clear_tag.asd lib/cl-glfw-opengl-ext_stencil_two_side.asd lib/cl-glfw-opengl-ext_stencil_wrap.asd lib/cl-glfw-opengl-ext_subtexture.asd lib/cl-glfw-opengl-ext_texture.asd lib/cl-glfw-opengl-ext_texture3d.asd lib/cl-glfw-opengl-ext_texture_array.asd lib/cl-glfw-opengl-ext_texture_buffer_object.asd lib/cl-glfw-opengl-ext_texture_compression_latc.asd lib/cl-glfw-opengl-ext_texture_compression_rgtc.asd lib/cl-glfw-opengl-ext_texture_compression_s3tc.asd lib/cl-glfw-opengl-ext_texture_cube_map.asd lib/cl-glfw-opengl-ext_texture_env_combine.asd lib/cl-glfw-opengl-ext_texture_env_dot3.asd lib/cl-glfw-opengl-ext_texture_filter_anisotropic.asd lib/cl-glfw-opengl-ext_texture_integer.asd lib/cl-glfw-opengl-ext_texture_lod_bias.asd lib/cl-glfw-opengl-ext_texture_mirror_clamp.asd lib/cl-glfw-opengl-ext_texture_object.asd lib/cl-glfw-opengl-ext_texture_perturb_normal.asd lib/cl-glfw-opengl-ext_texture_shared_exponent.asd lib/cl-glfw-opengl-ext_texture_snorm.asd lib/cl-glfw-opengl-ext_texture_srgb.asd lib/cl-glfw-opengl-ext_texture_srgb_decode.asd lib/cl-glfw-opengl-ext_texture_swizzle.asd lib/cl-glfw-opengl-ext_timer_query.asd lib/cl-glfw-opengl-ext_transform_feedback.asd lib/cl-glfw-opengl-ext_vertex_array.asd lib/cl-glfw-opengl-ext_vertex_array_bgra.asd lib/cl-glfw-opengl-ext_vertex_attrib_64bit.asd lib/cl-glfw-opengl-ext_vertex_shader.asd lib/cl-glfw-opengl-ext_vertex_weighting.asd lib/cl-glfw-opengl-gremedy_frame_terminator.asd lib/cl-glfw-opengl-gremedy_string_marker.asd lib/cl-glfw-opengl-hp_convolution_border_modes.asd lib/cl-glfw-opengl-hp_image_transform.asd lib/cl-glfw-opengl-hp_occlusion_test.asd lib/cl-glfw-opengl-hp_texture_lighting.asd lib/cl-glfw-opengl-ibm_cull_vertex.asd lib/cl-glfw-opengl-ibm_multimode_draw_arrays.asd lib/cl-glfw-opengl-ibm_rasterpos_clip.asd lib/cl-glfw-opengl-ibm_texture_mirrored_repeat.asd lib/cl-glfw-opengl-ibm_vertex_array_lists.asd lib/cl-glfw-opengl-ingr_blend_func_separate.asd lib/cl-glfw-opengl-ingr_color_clamp.asd lib/cl-glfw-opengl-ingr_interlace_read.asd lib/cl-glfw-opengl-intel_parallel_arrays.asd lib/cl-glfw-opengl-mesa_pack_invert.asd lib/cl-glfw-opengl-mesa_packed_depth_stencil.asd lib/cl-glfw-opengl-mesa_program_debug.asd lib/cl-glfw-opengl-mesa_resize_buffers.asd lib/cl-glfw-opengl-mesa_shader_debug.asd lib/cl-glfw-opengl-mesa_trace.asd lib/cl-glfw-opengl-mesa_window_pos.asd lib/cl-glfw-opengl-mesa_ycbcr_texture.asd lib/cl-glfw-opengl-mesax_texture_stack.asd lib/cl-glfw-opengl-nv_conditional_render.asd lib/cl-glfw-opengl-nv_copy_depth_to_color.asd lib/cl-glfw-opengl-nv_copy_image.asd lib/cl-glfw-opengl-nv_depth_buffer_float.asd lib/cl-glfw-opengl-nv_depth_clamp.asd lib/cl-glfw-opengl-nv_evaluators.asd lib/cl-glfw-opengl-nv_explicit_multisample.asd lib/cl-glfw-opengl-nv_fence.asd lib/cl-glfw-opengl-nv_float_buffer.asd lib/cl-glfw-opengl-nv_fog_distance.asd lib/cl-glfw-opengl-nv_fragment_program.asd lib/cl-glfw-opengl-nv_fragment_program2.asd lib/cl-glfw-opengl-nv_framebuffer_multisample_coverage.asd lib/cl-glfw-opengl-nv_geometry_program4.asd lib/cl-glfw-opengl-nv_gpu_program4.asd lib/cl-glfw-opengl-nv_gpu_program5.asd lib/cl-glfw-opengl-nv_gpu_shader5.asd lib/cl-glfw-opengl-nv_half_float.asd lib/cl-glfw-opengl-nv_light_max_exponent.asd lib/cl-glfw-opengl-nv_multisample_coverage.asd lib/cl-glfw-opengl-nv_multisample_filter_hint.asd lib/cl-glfw-opengl-nv_occlusion_query.asd lib/cl-glfw-opengl-nv_packed_depth_stencil.asd lib/cl-glfw-opengl-nv_parameter_buffer_object.asd lib/cl-glfw-opengl-nv_pixel_data_range.asd lib/cl-glfw-opengl-nv_point_sprite.asd lib/cl-glfw-opengl-nv_present_video.asd lib/cl-glfw-opengl-nv_primitive_restart.asd lib/cl-glfw-opengl-nv_register_combiners.asd lib/cl-glfw-opengl-nv_register_combiners2.asd lib/cl-glfw-opengl-nv_shader_buffer_load.asd lib/cl-glfw-opengl-nv_shader_buffer_store.asd lib/cl-glfw-opengl-nv_tessellation_program5.asd lib/cl-glfw-opengl-nv_texgen_emboss.asd lib/cl-glfw-opengl-nv_texgen_reflection.asd lib/cl-glfw-opengl-nv_texture_barrier.asd lib/cl-glfw-opengl-nv_texture_env_combine4.asd lib/cl-glfw-opengl-nv_texture_expand_normal.asd lib/cl-glfw-opengl-nv_texture_multisample.asd lib/cl-glfw-opengl-nv_texture_rectangle.asd lib/cl-glfw-opengl-nv_texture_shader.asd lib/cl-glfw-opengl-nv_texture_shader2.asd lib/cl-glfw-opengl-nv_texture_shader3.asd lib/cl-glfw-opengl-nv_transform_feedback.asd lib/cl-glfw-opengl-nv_transform_feedback2.asd lib/cl-glfw-opengl-nv_vertex_array_range.asd lib/cl-glfw-opengl-nv_vertex_array_range2.asd lib/cl-glfw-opengl-nv_vertex_attrib_integer_64bit.asd lib/cl-glfw-opengl-nv_vertex_buffer_unified_memory.asd lib/cl-glfw-opengl-nv_vertex_program.asd lib/cl-glfw-opengl-nv_vertex_program2_option.asd lib/cl-glfw-opengl-nv_vertex_program3.asd lib/cl-glfw-opengl-nv_vertex_program4.asd lib/cl-glfw-opengl-oes_read_format.asd lib/cl-glfw-opengl-oml_interlace.asd lib/cl-glfw-opengl-oml_resample.asd lib/cl-glfw-opengl-oml_subsample.asd lib/cl-glfw-opengl-pgi_misc_hints.asd lib/cl-glfw-opengl-pgi_vertex_hints.asd lib/cl-glfw-opengl-rend_screen_coordinates.asd lib/cl-glfw-opengl-s3_s3tc.asd lib/cl-glfw-opengl-sgi_color_table.asd lib/cl-glfw-opengl-sgi_depth_pass_instrument.asd lib/cl-glfw-opengl-sgis_detail_texture.asd lib/cl-glfw-opengl-sgis_fog_function.asd lib/cl-glfw-opengl-sgis_multisample.asd lib/cl-glfw-opengl-sgis_pixel_texture.asd lib/cl-glfw-opengl-sgis_point_parameters.asd lib/cl-glfw-opengl-sgis_sharpen_texture.asd lib/cl-glfw-opengl-sgis_texture4d.asd lib/cl-glfw-opengl-sgis_texture_color_mask.asd lib/cl-glfw-opengl-sgis_texture_filter4.asd lib/cl-glfw-opengl-sgis_texture_select.asd lib/cl-glfw-opengl-sgix_async.asd lib/cl-glfw-opengl-sgix_depth_texture.asd lib/cl-glfw-opengl-sgix_flush_raster.asd lib/cl-glfw-opengl-sgix_fog_scale.asd lib/cl-glfw-opengl-sgix_fragment_lighting.asd lib/cl-glfw-opengl-sgix_framezoom.asd lib/cl-glfw-opengl-sgix_igloo_interface.asd lib/cl-glfw-opengl-sgix_instruments.asd lib/cl-glfw-opengl-sgix_line_quality_hint.asd lib/cl-glfw-opengl-sgix_list_priority.asd lib/cl-glfw-opengl-sgix_pixel_texture.asd lib/cl-glfw-opengl-sgix_polynomial_ffd.asd lib/cl-glfw-opengl-sgix_reference_plane.asd lib/cl-glfw-opengl-sgix_resample.asd lib/cl-glfw-opengl-sgix_scalebias_hint.asd lib/cl-glfw-opengl-sgix_shadow.asd lib/cl-glfw-opengl-sgix_shadow_ambient.asd lib/cl-glfw-opengl-sgix_slim.asd lib/cl-glfw-opengl-sgix_sprite.asd lib/cl-glfw-opengl-sgix_tag_sample_buffer.asd lib/cl-glfw-opengl-sgix_texture_coordinate_clamp.asd lib/cl-glfw-opengl-sgix_texture_lod_bias.asd lib/cl-glfw-opengl-sgix_texture_multi_buffer.asd lib/cl-glfw-opengl-sgix_ycrcba.asd lib/cl-glfw-opengl-sun_convolution_border_modes.asd lib/cl-glfw-opengl-sun_global_alpha.asd lib/cl-glfw-opengl-sun_mesh_array.asd lib/cl-glfw-opengl-sun_slice_accum.asd lib/cl-glfw-opengl-sun_triangle_list.asd lib/cl-glfw-opengl-sun_vertex.asd lib/cl-glfw-opengl-sunx_constant_data.asd lib/cl-glfw-opengl-win_phong_shading.asd lib/cl-glfw-opengl-win_specular_fog.asd
cl-glfw3 http://beta.quicklisp.org/archive/cl-glfw3/2021-05-31/cl-glfw3-20210531-git.tgz 14642 3309ed23c7dffce0cd6759550c3a21d9 f5b86163d1d8e2406793e9214670e34d7181e79f cl-glfw3-20210531-git cl-glfw3-examples.asd cl-glfw3.asd
cl-glib http://beta.quicklisp.org/archive/cl-glib/2022-11-06/cl-glib-20221106-git.tgz 4787 90ace4f1f890bd49e2a7c45737ec560b d10223ffba22be627419a2ab378e86fa5e71037a cl-glib-20221106-git cl-glib.asd cl-glib.gio.asd cl-glib.gobject.asd
cl-gltf http://beta.quicklisp.org/archive/cl-gltf/2022-03-31/cl-gltf-20220331-git.tgz 24847 e323a55e9c79708662372cf3154ed7a0 5c21728445377a6acce9320ab11251580f2339ec cl-gltf-20220331-git cl-gltf.asd
cl-gobject-introspection http://beta.quicklisp.org/archive/cl-gobject-introspection/2021-01-24/cl-gobject-introspection-20210124-git.tgz 43072 ad760b820c86142c0a1309af29541680 f97e90e24bbed4cd30246836b9ae3920d76b4710 cl-gobject-introspection-20210124-git cl-gobject-introspection-test.asd cl-gobject-introspection.asd
cl-gobject-introspection-wrapper http://beta.quicklisp.org/archive/cl-gobject-introspection-wrapper/2022-11-06/cl-gobject-introspection-wrapper-20221106-git.tgz 8672 2947a9b43c4f6a0dec03da7710a78333 94391fa73fd6153385740e7a43af2aebac4de9b1 cl-gobject-introspection-wrapper-20221106-git cl-gobject-introspection-wrapper.asd
cl-gopher http://beta.quicklisp.org/archive/cl-gopher/2022-03-31/cl-gopher-20220331-git.tgz 10478 8b3636509524fdf9a1922efb052c4e59 1ab2500806e6a79516b7ed3391a3c3f682261f57 cl-gopher-20220331-git cl-gopher.asd
cl-gpio http://beta.quicklisp.org/archive/cl-gpio/2021-12-09/cl-gpio-20211209-git.tgz 9353 f9777c96836b5b2132d071f46a071ee5 f27176cbe4292ade24bf6b7afeff2f1713860eb2 cl-gpio-20211209-git cl-gpio.asd
cl-graph http://beta.quicklisp.org/archive/cl-graph/2017-12-27/cl-graph-20171227-git.tgz 60626 b133594d59ade148c07ad6fdec4cbdf6 2163417e2d2d61b2ad9d7c4eac1298d33573cdeb cl-graph-20171227-git cl-graph+hu.dwim.graphviz.asd cl-graph.asd
cl-gravatar http://beta.quicklisp.org/archive/cl-gravatar/2011-03-20/cl-gravatar-20110320-git.tgz 2127 6d4e5c83f238a7c301a572ddc926ef9b ae2e3b442465a3395c5f7d0948346bcd9562664e cl-gravatar-20110320-git gravatar.asd
cl-graylog http://beta.quicklisp.org/archive/cl-graylog/2018-04-30/cl-graylog-20180430-git.tgz 3582 4a821f6c2a6496f3fa7fefb4052186d5 5aa806c058074da350fd0208d5049bf1d4b1e4b9 cl-graylog-20180430-git graylog-log5.asd graylog.asd
cl-grip http://beta.quicklisp.org/archive/cl-grip/2021-10-20/cl-grip-20211020-git.tgz 16546 cd100c21194692030f639ab925e69b66 f0b4db31df493490af718d38820aa183976cfccf cl-grip-20211020-git cl-grip.asd
cl-grnm http://beta.quicklisp.org/archive/cl-grnm/2018-01-31/cl-grnm-20180131-git.tgz 9511 9442e2489cf6894f4e61f9ec610d5c04 0609e0ac48299f120f71c2b86b7fec1f14897a08 cl-grnm-20180131-git cl-grnm.asd
cl-groupby http://beta.quicklisp.org/archive/cl-groupby/2017-08-30/cl-groupby-20170830-git.tgz 4240 5eab5f4784f0a154087daa7aa0caa930 9d7699457042096e05968c011013ad27b9271613 cl-groupby-20170830-git groupby.asd
cl-growl http://beta.quicklisp.org/archive/cl-growl/2016-12-08/cl-growl-20161208-git.tgz 9956 2a99024043323daf84837ae36fb89b2c 6dd1dfb8cec367fe2602a0b2b1bbaff83130f86c cl-growl-20161208-git cl-growl.asd
cl-gserver http://beta.quicklisp.org/archive/cl-gserver/2022-11-06/cl-gserver-20221106-git.tgz 759077 a5480d865905031585a8f01a30eaa530 5d8b92d13a5c28c46e773b6e2098397b163d4833 cl-gserver-20221106-git sento.asd
cl-gss http://beta.quicklisp.org/archive/cl-gss/2018-02-28/cl-gss-20180228-git.tgz 11188 62e9ab1eb233059a0b7f2276a95814d0 23537f4151f9472047e0725bd9e1f2899e766088 cl-gss-20180228-git cl-gss.asd
cl-gtk2 http://beta.quicklisp.org/archive/cl-gtk2/2021-10-20/cl-gtk2-20211020-git.tgz 385017 1e4c2a29fb53cf8cce46c4a596f69823 a5dc2aafc070b34b1ab09fdcd59dfed9ddd7b9c0 cl-gtk2-20211020-git gdk/cl-gtk2-gdk.asd glib/cl-gtk2-glib.asd pango/cl-gtk2-pango.asd
cl-hamcrest http://beta.quicklisp.org/archive/cl-hamcrest/2022-02-20/cl-hamcrest-20220220-git.tgz 27301 18bdf5d8576f6ce2ee0e4e134a8f20cc 354903e0a5fb7acd9f7230df0a06af1b45ec6b32 cl-hamcrest-20220220-git hamcrest.asd
cl-haml http://beta.quicklisp.org/archive/cl-haml/2018-02-28/cl-haml-20180228-git.tgz 17830 0cc73c605a2f182eec47b645ace67498 474bdbb68dfaea7ffefd3396a6b1c14c63ecdfcb cl-haml-20180228-git cl-haml.asd
cl-hamt http://beta.quicklisp.org/archive/cl-hamt/2020-03-25/cl-hamt-20200325-git.tgz 14108 00d8149d1b7178697404ae292761d56a 675720b4cfa7c1bd3c4e08298e0eeec2aba8db6a cl-hamt-20200325-git cl-hamt-examples.asd cl-hamt-test.asd cl-hamt.asd
cl-hash-table-destructuring http://beta.quicklisp.org/archive/cl-hash-table-destructuring/2016-05-31/cl-hash-table-destructuring-20160531-git.tgz 2604 05fb57c755f09ec4f2f5933fdaaedd4c 40d1d6441dd49fb7c51896d5f518d1addf4d2b7c cl-hash-table-destructuring-20160531-git cl-hash-table-destructuring.asd
cl-hash-util http://beta.quicklisp.org/archive/cl-hash-util/2019-01-07/cl-hash-util-20190107-git.tgz 7291 ff5044132c9684cf49f8b841096c67a2 c39b42dde00c70c608089c1c58c958bf46d152e9 cl-hash-util-20190107-git cl-hash-util-test.asd cl-hash-util.asd
cl-heap http://beta.quicklisp.org/archive/cl-heap/2013-03-12/cl-heap-0.1.6.tgz 26979 a12d71f7bbe22d6acdcc7cf36fb907b0 defa03668605e5a14a0431715adf2febf0aaa65a cl-heap-0.1.6 cl-heap-tests.asd cl-heap.asd
cl-heredoc http://beta.quicklisp.org/archive/cl-heredoc/2022-07-07/cl-heredoc-20220707-git.tgz 17336 5f94cf024fb30519725816ca9c59d167 2360919aeaa9f434b4fd486f9437bf6b372931d6 cl-heredoc-20220707-git cl-heredoc-test.asd cl-heredoc.asd
cl-html-diff http://beta.quicklisp.org/archive/cl-html-diff/2013-01-28/cl-html-diff-20130128-git.tgz 4134 70f93e60e968dad9a44ede60856dc343 62480247479faf7bad6c1bbd4f4135ac2485694e cl-html-diff-20130128-git cl-html-diff.asd
cl-html-parse http://beta.quicklisp.org/archive/cl-html-parse/2020-09-25/cl-html-parse-20200925-git.tgz 24755 3333eedf037a48900c663fceae3e4cfd e0ff6f78f80aa226f4f6939eae69e276a8fd710f cl-html-parse-20200925-git cl-html-parse.asd
cl-html-readme http://beta.quicklisp.org/archive/cl-html-readme/2021-02-28/cl-html-readme-quicklisp-current-release-fa304a63-git.tgz 13877 26b27e698d0dbd108e0aace4b9435465 7c3f4521f13121d47bd5e1b4d3a48e22da647873 cl-html-readme-quicklisp-current-release-fa304a63-git cl-html-readme.asd
cl-html5-parser http://beta.quicklisp.org/archive/cl-html5-parser/2019-05-21/cl-html5-parser-20190521-git.tgz 192746 149e5609d0a96c867fac6c22693c5e30 4b9882d952d5cf90ce0c874e0b134a04db64d0a4 cl-html5-parser-20190521-git cl-html5-parser.asd cxml/cl-html5-parser-cxml.asd tests/cl-html5-parser-tests.asd
cl-htmlprag http://beta.quicklisp.org/archive/cl-htmlprag/2016-06-28/cl-htmlprag-20160628-git.tgz 41128 8232a485fcb90e422bca541c4e81c263 3a1eb22bd66998acf5eb018237f4a85e0935d6c8 cl-htmlprag-20160628-git cl-htmlprag.asd
cl-httpsqs http://beta.quicklisp.org/archive/cl-httpsqs/2018-02-28/cl-httpsqs-20180228-git.tgz 2303 4ed58c978ada913cbff3fffa002f15eb 446c6bd9937ed987e9ed7bd0023b44512cb462c8 cl-httpsqs-20180228-git cl-httpsqs.asd
cl-hue http://beta.quicklisp.org/archive/cl-hue/2015-01-13/cl-hue-20150113-git.tgz 2734 c5703adb29241896c35f365be6470811 51c697d52abb18f0a370c50c7d9e83cf8d84c43a cl-hue-20150113-git cl-hue.asd
cl-i18n http://beta.quicklisp.org/archive/cl-i18n/2022-11-06/cl-i18n-20221106-git.tgz 55059 cd41a0e077eb34fa04c0db5abddec3e5 50c0c4837048a1964bbb77aea06c3cbd00ba40ae cl-i18n-20221106-git cl-i18n.asd
cl-iconv http://beta.quicklisp.org/archive/cl-iconv/2017-12-27/cl-iconv-20171227-git.tgz 4909 3b6bccf9f50224194d2d0910cd563a6a 3509872d765d9d3a7557cecaa8fadd804f46fc4c cl-iconv-20171227-git iconv.asd
cl-incognia http://beta.quicklisp.org/archive/cl-incognia/2021-12-30/cl-incognia-20211230-git.tgz 7012 3f30a8fb30e0a403116b47a0b8cb729e e91181c2917d878163efe19839d09767948ca860 cl-incognia-20211230-git cl-incognia.asd
cl-indentify http://beta.quicklisp.org/archive/cl-indentify/2020-09-25/cl-indentify-20200925-git.tgz 10559 d4dd445c9f239c8ff23e8f5c3e5b0e5e 482dbeee26e1da6aaa9d282fc0440d83b7c2f08d cl-indentify-20200925-git cl-indentify.asd
cl-inflector http://beta.quicklisp.org/archive/cl-inflector/2015-01-13/cl-inflector-20150113-git.tgz 6368 8563dd864200dc23b64648581ccec94f 7ef99cde744b4c4645bac4ea440fc1f2a709fdee cl-inflector-20150113-git cl-inflector.asd
cl-influxdb http://beta.quicklisp.org/archive/cl-influxdb/2018-01-31/cl-influxdb-20180131-git.tgz 15600 a34f8d1f70690f6c19465f9bd65f491c 8eb53449dbba61449beec84d34dcc989b06dd5a3 cl-influxdb-20180131-git cl-influxdb.asd
cl-info http://beta.quicklisp.org/archive/cl-info/2022-11-06/cl-info-20221106-git.tgz 7970 e85ee72ba0170bfc151b6111f438422c 2654e76778bcea83f27c6176a2c6063b5e31e205 cl-info-20221106-git cl-info-test.asd cl-info.asd
cl-ini http://beta.quicklisp.org/archive/cl-ini/2020-12-20/cl-ini-20201220-git.tgz 2753 ba16d72675a2b96cb4c7e6f60d5a25f7 3371e6d7b1393111d724073515a531398d15d7da cl-ini-20201220-git cl-ini-test.asd cl-ini.asd
cl-inotify http://beta.quicklisp.org/archive/cl-inotify/2022-07-07/cl-inotify-20220707-git.tgz 11726 df666de01f79c34000246c032e7a074f 2164f205e0426b0f6812898fed71703008d186ba cl-inotify-20220707-git cl-inotify-tests.asd cl-inotify.asd
cl-intbytes http://beta.quicklisp.org/archive/cl-intbytes/2015-09-23/cl-intbytes-20150923-git.tgz 3789 690cdfa2b0bc4829eeb1f8606291f0f5 f2a1bf6b3052fbd84755e3589d3370511f86b05c cl-intbytes-20150923-git cl-intbytes-test.asd cl-intbytes.asd
cl-interpol http://beta.quicklisp.org/archive/cl-interpol/2022-11-06/cl-interpol-20221106-git.tgz 43666 cc2335e703dea4016af0ce935a5dd07e c6a60bdd880b1e47698abc9d17a9526492633c5e cl-interpol-20221106-git cl-interpol.asd
cl-interval http://beta.quicklisp.org/archive/cl-interval/2020-07-15/cl-interval-20200715-git.tgz 10609 22fa5053c3fcbbf0fedebf0a3dffa38a 56dae5e7501d9255853fe9153f03189bc54d01a9 cl-interval-20200715-git cl-interval-docs.asd cl-interval.asd
cl-ipfs-api2 http://beta.quicklisp.org/archive/cl-ipfs-api2/2021-06-30/cl-ipfs-api2-20210630-git.tgz 15080 09d700b4ba26cbcfb7a4426882ff58cc bc83bdc1315608a4a6ce551d1da03b990710b4fd cl-ipfs-api2-20210630-git cl-ipfs-api2.asd
cl-irc http://beta.quicklisp.org/archive/cl-irc/2015-09-23/cl-irc-0.9.2.tgz 921763 73e8ba73d8e4222cec427704c1a6aabd 8f0bf062ea520bfb6e4b0a0395c85c4250425cfb cl-irc-0.9.2 cl-irc.asd test/cl-irc-test.asd
cl-irregsexp http://beta.quicklisp.org/archive/cl-irregsexp/2016-08-25/cl-irregsexp-20160825-git.tgz 21596 717edf273168ca0ca638dcb8721ce4ac 40dd190eaf28eea03b2208469408590b390d07c2 cl-irregsexp-20160825-git cl-irregsexp.asd
cl-isaac http://beta.quicklisp.org/archive/cl-isaac/2022-11-06/cl-isaac-20221106-git.tgz 8814 8049ff77676d2362e6355e11a61d88f0 51ba71a93610bdb140f329df16e27bc5dff48da6 cl-isaac-20221106-git cl-isaac.asd
cl-isolated http://beta.quicklisp.org/archive/cl-isolated/2020-02-18/cl-isolated-20200218-git.tgz 19937 821b4b00dc524fc49a65fdda4dba3350 83ece69656138758b0737c90544914c38b347475 cl-isolated-20200218-git isolated.asd
cl-iterative http://beta.quicklisp.org/archive/cl-iterative/2016-03-18/cl-iterative-20160318-git.tgz 8987 7fc7c0e9e4451fc95b57db27e2e42f2c 85c5a21c03dc6e5c88bc3c9a2c1ece9731732a91 cl-iterative-20160318-git cl-iterative-tests.asd cl-iterative.asd
cl-itertools http://beta.quicklisp.org/archive/cl-itertools/2016-04-21/cl-itertools-20160421-git.tgz 6199 03577f82ecdbba2ed0977237a06c0017 97812f1df7ea506f413fee176e6897c85962a1bd cl-itertools-20160421-git cl-itertools.asd
cl-ixf http://beta.quicklisp.org/archive/cl-ixf/2018-02-28/cl-ixf-20180228-git.tgz 8677 23732795aa317d24c1a40cc321a0e394 7b99b33ef1a21049bc8eac1245f1d87fb38f98ea cl-ixf-20180228-git ixf.asd
cl-jpeg http://beta.quicklisp.org/archive/cl-jpeg/2017-06-30/cl-jpeg-20170630-git.tgz 25088 b6eb4ca5d893f428b5bbe46cd49f76ad 1e8f15736d3c038aae73b8283c5d13b50e23bdd0 cl-jpeg-20170630-git cl-jpeg.asd
cl-jpl-util http://beta.quicklisp.org/archive/cl-jpl-util/2015-10-31/cl-jpl-util-20151031-git.tgz 36026 e294bedace729724873e7633b8265a00 0d6d0d8d68c636de34c02e5b0f15b34758e50ac5 cl-jpl-util-20151031-git jpl-util.asd
cl-json http://beta.quicklisp.org/archive/cl-json/2022-07-07/cl-json-20220707-git.tgz 65728 95a7d92bf0e1e930f7f859c0aae5a2fc b03302b3c21a9068ce2e8403762463c189cfdee7 cl-json-20220707-git cl-json.asd
cl-json-helper http://beta.quicklisp.org/archive/cl-json-helper/2018-12-10/cl-json-helper-20181210-git.tgz 2779 a681ca1edff40c68c65e2a6f4457ac01 38cfe3a53def3c09c9b013bc09a9b0c18577f24a cl-json-helper-20181210-git cl-json-helper.asd
cl-json-pointer http://beta.quicklisp.org/archive/cl-json-pointer/2022-11-06/cl-json-pointer-20221106-git.tgz 23021 4147a61e129dc10b5fd74967ae5d6895 c1f12b3dac48e268298f9a5d189b12808d2a15da cl-json-pointer-20221106-git cl-json-pointer.asd
cl-json-schema http://beta.quicklisp.org/archive/cl-json-schema/2021-02-28/cl-json-schema-20210228-git.tgz 10520 c0299dbdcb97bb418c0dd738ac126ec3 d49b93b456532aebde56f262c059ca973873acbf cl-json-schema-20210228-git cl-json-schema-tests.asd cl-json-schema.asd
cl-jsx http://beta.quicklisp.org/archive/cl-jsx/2016-02-08/cl-jsx-20160208-git.tgz 6265 4e93808606526155d02fd3262e84e8bb 3e7d40b520e361bd8bc2dcd4c6e1fd92c3933672 cl-jsx-20160208-git cl-jsx-test.asd cl-jsx.asd
cl-junit-xml http://beta.quicklisp.org/archive/cl-junit-xml/2015-01-13/cl-junit-xml-20150113-git.tgz 5173 2a8e063e7431b6380ef6a6d268075af3 3d075953049523bb9b6071878607f59344201121 cl-junit-xml-20150113-git cl-junit-xml.asd cl-junit-xml.lisp-unit.asd cl-junit-xml.lisp-unit2.asd
cl-just-getopt-parser http://beta.quicklisp.org/archive/cl-just-getopt-parser/2021-12-09/cl-just-getopt-parser-20211209-git.tgz 7340 2a19b8357e128d295b55422106022742 f85a97958be75d74e72c15fd4ee67b01295277f5 cl-just-getopt-parser-20211209-git just-getopt-parser.asd
cl-k8055 http://beta.quicklisp.org/archive/cl-k8055/2019-07-10/cl-k8055-20190710-git.tgz 32114 4038e38dfb899c604beb50682fc85ace c20da9e467984ec6a920f95d12e1d60b1dcfb322 cl-k8055-20190710-git cl-k8055.asd
cl-kanren http://beta.quicklisp.org/archive/cl-kanren/2019-10-07/cl-kanren-20191007-git.tgz 12189 c6a29b570ac5047d4c5b1eb05a9f3b34 f11814e7348abcc947e9f22cfba4974d1277b691 cl-kanren-20191007-git cl-kanren.asd tests/cl-kanren-test.asd
cl-kanren-trs http://beta.quicklisp.org/archive/cl-kanren-trs/2012-03-05/cl-kanren-trs-20120305-svn.tgz 11024 7be1f8c2a6b396bf2403a51d9f5cd4b2 76bc8c61f0425273e137925aa278072284d5f6ef cl-kanren-trs-20120305-svn cl-kanren-trs/kanren-trs.asd cl-kanren-trs/tests/kanren-trs-test.asd
cl-kaputt http://beta.quicklisp.org/archive/cl-kaputt/2022-11-06/cl-kaputt-20221106-git.tgz 29536 6c58bd98093878ad66f30954e7b5d231 110877feb3447929a9828bdf8760efdf87f51b1b cl-kaputt-20221106-git kaputt.asd
cl-keycloak http://beta.quicklisp.org/archive/cl-keycloak/2019-07-10/cl-keycloak-20190710-git.tgz 13878 c1fd4adadecb6bb9c8db69ea2a4a731e 08895e7fe14432588a82c1920c30d1865bbe63ea cl-keycloak-20190710-git cl-keycloak.asd
cl-kraken http://beta.quicklisp.org/archive/cl-kraken/2022-03-31/cl-kraken-20220331-git.tgz 29838 72317d99258d04994b09fe318401dc7f 87414ad0e6627f0bc7c6d612200dcac761af9d85 cl-kraken-20220331-git cl-kraken.asd
cl-ksuid http://beta.quicklisp.org/archive/cl-ksuid/2017-08-30/cl-ksuid-20170830-git.tgz 15810 0d6c51c80711463b0d276455fc2d4bf9 63b788ba0f5bb0d1e4c436979e4be5a053b10994 cl-ksuid-20170830-git cl-ksuid.asd
cl-kyoto-cabinet http://beta.quicklisp.org/archive/cl-kyoto-cabinet/2019-11-30/cl-kyoto-cabinet-20191130-git.tgz 11166 e9ec82383fe859240e7711142878f8fa 9921f6a8e5750dfe6c300c3e6a7ccc41543bc203 cl-kyoto-cabinet-20191130-git cl-kyoto-cabinet.asd
cl-l10n http://beta.quicklisp.org/archive/cl-l10n/2021-12-09/cl-l10n-20211209-git.tgz 66567 e575bb4ff3a6d0bbba5220c631f9c83a 44515bbda062b64a324f9e2aa8ba3222e255bfeb cl-l10n-20211209-git cl-l10n.asd
cl-l10n-cldr http://beta.quicklisp.org/archive/cl-l10n-cldr/2012-09-09/cl-l10n-cldr-20120909-darcs.tgz 3538114 466e776f2f6b931d9863e1fc4d0b514e 6b3a2e8fbf2b933e13d85fb21d87943eac67cbf8 cl-l10n-cldr-20120909-darcs cl-l10n-cldr.asd
cl-lambdacalc http://beta.quicklisp.org/archive/cl-lambdacalc/2022-03-31/cl-lambdacalc-20220331-git.tgz 4399 0b337037ba70d2fee320626ce5626a5d e8d5c9a6f51fce68f739278231e225c3ee3bfb5f cl-lambdacalc-20220331-git app/cl-lambdacalc.asd test/cl-lambdacalc-test.asd
cl-langutils http://beta.quicklisp.org/archive/cl-langutils/2012-11-25/cl-langutils-20121125-git.tgz 2482768 ba2d1e4abbc7757c135273d76e8147db 0861ac6408e69c6bb155dc62a637ede5fac467de cl-langutils-20121125-git langutils.asd
cl-las http://beta.quicklisp.org/archive/cl-las/2022-11-06/cl-las-20221106-git.tgz 11405 570918f3a5022beb0936f6c9424c807d fd8805f94404ec262d707d9584fdde41989caf82 cl-las-20221106-git cl-las.asd
cl-lastfm http://beta.quicklisp.org/archive/cl-lastfm/2014-07-13/cl-lastfm-0.2.1.tgz 22260 2eb42fa1964fe361108aa752fe7a9089 160d3d3dce74b91fadef38768494f1785882ad5b cl-lastfm-0.2.1 cl-lastfm-test.asd cl-lastfm.asd
cl-launch http://beta.quicklisp.org/archive/cl-launch/2015-10-31/cl-launch-4.1.4.1.tgz 94539 5f3d1dc76a5c734a8fd2dba5e567f2ad e809f8f3dcbb3d0b3f239ef3ade7686005aee383 cl-launch-4.1.4.1 cl-launch.asd
cl-ledger http://beta.quicklisp.org/archive/cl-ledger/2020-02-18/cl-ledger-20200218-git.tgz 1183090 46d7a3c5f0e284e868b05cb5100af9d9 575534a3fc8e45910662a1c78a2a1f9549fc42f3 cl-ledger-20200218-git cl-ledger.asd
cl-lessp http://beta.quicklisp.org/archive/cl-lessp/2022-11-06/cl-lessp-20221106-git.tgz 1954 dd21c43ccf95766185bf9a47d5fd1769 4a6587ff7f343cf936e1ae35eed43f14c72b7eca cl-lessp-20221106-git lessp.asd
cl-lex http://beta.quicklisp.org/archive/cl-lex/2016-09-29/cl-lex-20160929-git.tgz 15959 03ca8860afad55575c8747a12e58370a 249a1fb7e5d2070536213b83e9608bcba9cd79b1 cl-lex-20160929-git cl-lex.asd
cl-lexer http://beta.quicklisp.org/archive/cl-lexer/2019-10-07/cl-lexer-20191007-git.tgz 5477 810e054e68d67b18eaa3859114b62662 e8b213a35c04e07c34ca676ee5f7919548e092e2 cl-lexer-20191007-git cl-lexer.asd
cl-lib-helper http://beta.quicklisp.org/archive/cl-lib-helper/2022-11-06/cl-lib-helper-20221106-git.tgz 64929 b91685caa2b040fc92ceb5aae16bc399 3c75df7144b1f28d78b1790b7723a256af52e8d5 cl-lib-helper-20221106-git lib-helper.asd test/test-system/lib-helper-test-system.asd
cl-liballegro http://beta.quicklisp.org/archive/cl-liballegro/2022-11-06/cl-liballegro-20221106-git.tgz 53184 b1ebce5e69f31c641faeef2b8421e1ff b74b3d723f5d84e7a6357a8de97f95c408a50c25 cl-liballegro-20221106-git cl-liballegro.asd
cl-liballegro-nuklear http://beta.quicklisp.org/archive/cl-liballegro-nuklear/2022-11-06/cl-liballegro-nuklear-20221106-git.tgz 487819 d1a5a6d3d8ec3de455e3440f6c8d8003 0c150edba55ab8b78d37c69b418396ed044af20b cl-liballegro-nuklear-20221106-git cl-liballegro-nuklear.asd
cl-libevent2 http://beta.quicklisp.org/archive/cl-libevent2/2019-01-07/cl-libevent2-20190107-git.tgz 17801 e6cf8f0a5ead1184043107ae05505309 a0f45ed59ab51638f6a3081ab21a476ad495ea5d cl-libevent2-20190107-git cl-libevent2-ssl.asd cl-libevent2.asd
cl-libfarmhash http://beta.quicklisp.org/archive/cl-libfarmhash/2016-10-31/cl-libfarmhash-20161031-git.tgz 14254 18f1d5557e8cb18a8508d5aea161c29b f6246aa6bfc3d7d6add3f2f3cabbe574341a87ae cl-libfarmhash-20161031-git cl-libfarmhash.asd
cl-libhoedown http://beta.quicklisp.org/archive/cl-libhoedown/2016-10-31/cl-libhoedown-20161031-git.tgz 6116 e3e02a0108dd00d7d3d47eb7cb8933ba 8265b5849763171d07d9132a68fdf035e1e61f7e cl-libhoedown-20161031-git cl-libhoedown.asd
cl-libiio http://beta.quicklisp.org/archive/cl-libiio/2019-11-30/cl-libiio-20191130-git.tgz 8149 cc70d023b770af0ecdfd1f9e401ee6ff 2caa1a95b175464b2447926ca089babaa7656877 cl-libiio-20191130-git cl-libiio.asd
cl-libinput http://beta.quicklisp.org/archive/cl-libinput/2022-07-07/cl-libinput-20220707-git.tgz 3698 cd09740b87c265cb8c2a1e7abf7ddd19 b5873d66b3cf4321a35585d072efaff4bb0cc255 cl-libinput-20220707-git cl-libinput.asd
cl-libpuzzle http://beta.quicklisp.org/archive/cl-libpuzzle/2015-06-08/cl-libpuzzle-20150608-git.tgz 2604 6721ae95e9eaaac4b5cb23403c43f67c 9515ee0dbfe8dfc9af92c36c5bdd97d2cd754c88 cl-libpuzzle-20150608-git cl-libpuzzle-test.asd cl-libpuzzle.asd
cl-libssh2 http://beta.quicklisp.org/archive/cl-libssh2/2016-05-31/cl-libssh2-20160531-git.tgz 21638 f4fdafbe1ef21b9e9c9e07dd564faacd 479298ef75e5cc50679e6eb052606b3a7ebe8df7 cl-libssh2-20160531-git libssh2.asd libssh2.test.asd
cl-libsvm http://beta.quicklisp.org/archive/cl-libsvm/2021-10-20/cl-libsvm-20211020-git.tgz 295777 9ac74abd58ac8f8fcd7810b3fae221f9 22fbeb82e9acb629018d915d0e7217e55e9e7e62 cl-libsvm-20211020-git cl-liblinear.asd cl-libsvm.asd
cl-libsvm-format http://beta.quicklisp.org/archive/cl-libsvm-format/2018-07-11/cl-libsvm-format-20180711-git.tgz 9951 bac7636204a46c66cdfa135cdd147ca6 87adb8326851e29f2c96f0a02dca122336d95520 cl-libsvm-format-20180711-git cl-libsvm-format-test.asd cl-libsvm-format.asd
cl-libusb http://beta.quicklisp.org/archive/cl-libusb/2021-02-28/cl-libusb-20210228-git.tgz 7807 ae227dc6c4e458ec1e26d1a4788f1f6a 606104c990fadf4284debc82138a11538357a5cc cl-libusb-20210228-git cl-libusb.asd libusb-ffi.asd
cl-libuv http://beta.quicklisp.org/archive/cl-libuv/2022-11-06/cl-libuv-20221106-git.tgz 14466 d8bf243a302e97629197914b1bf2330b 572d98d7137f7649c3997e4a91c2d2d63805b8e0 cl-libuv-20221106-git cl-libuv-config.asd cl-libuv.asd
cl-libxml2 http://beta.quicklisp.org/archive/cl-libxml2/2013-06-15/cl-libxml2-20130615-git.tgz 55579 88317bf302b5f1d2c1ac9efa6538fbe0 75977fe851405c2d85d67ed6df8dc3462628c661 cl-libxml2-20130615-git cl-libxml2.asd xfactory.asd xoverlay.asd
cl-libyaml http://beta.quicklisp.org/archive/cl-libyaml/2020-12-20/cl-libyaml-20201220-git.tgz 9421 2c8d064e95a1a06f854b8f2f875e66ab 0855f89ce8ae059c10aac9878856a9dde09b6fe8 cl-libyaml-20201220-git cl-libyaml-test.asd cl-libyaml.asd
cl-locale http://beta.quicklisp.org/archive/cl-locale/2015-10-31/cl-locale-20151031-git.tgz 3916 7a8fb3678938af6dc5c9fd6431428aff b5e33ecae4ad91db85d6f3ead72a52a02547fd23 cl-locale-20151031-git cl-locale-syntax.asd cl-locale-test.asd cl-locale.asd
cl-locatives http://beta.quicklisp.org/archive/cl-locatives/2019-03-07/cl-locatives-20190307-hg.tgz 2705 f7dc0d49dccf787bc27c859ede74537e 83d8f4cc9457e0d907b44ab9d1422e9f75cec721 cl-locatives-20190307-hg cl-locatives.asd
cl-log http://beta.quicklisp.org/archive/cl-log/2013-01-28/cl-log.1.0.1.tgz 18463 fb960933eb748c14adc3ccb376ac8066 79eba93cc6a981a79d95b35533063b70083c6353 cl-log.1.0.1 cl-log-test.asd cl-log.asd
cl-logic http://beta.quicklisp.org/archive/cl-logic/2014-12-17/cl-logic-20141217-git.tgz 19237 1d2c46cd6d6b22eec42b0634ee6aad02 832125e585ebc79b14bad28a34bab16dede39272 cl-logic-20141217-git cl-logic.asd
cl-ltsv http://beta.quicklisp.org/archive/cl-ltsv/2014-07-13/cl-ltsv-20140713-git.tgz 1768 b0f6141d4d431c30cd3f89ed9b915cf9 78beea35eb74ae8e22963cbe6f5e8b7e03d5a578 cl-ltsv-20140713-git cl-ltsv-test.asd cl-ltsv.asd
cl-lzlib http://beta.quicklisp.org/archive/cl-lzlib/2022-11-06/cl-lzlib-20221106-git.tgz 586870 89a814063c00675141e0871ae2c68a72 a6f59a528e0df2ea90c033248b1f2b7de7a27f0a cl-lzlib-20221106-git lzlib-tests.asd lzlib.asd
cl-lzma http://beta.quicklisp.org/archive/cl-lzma/2019-11-30/cl-lzma-20191130-git.tgz 391732 839b371f342610b221e8455ec0e5ab9e 2d6b69f5e810f08f2c943ed3b5a977041608e1cc cl-lzma-20191130-git cl-lzma.asd
cl-m4 http://beta.quicklisp.org/archive/cl-m4/2013-03-12/cl-m4-20130312-git.tgz 43800 1b3c29d5e7fb294f95afd4a845f4c6b4 7dbee2d1711f7b212ba1f6b9a04ac1ba873f4e31 cl-m4-20130312-git cl-m4-test.asd cl-m4.asd
cl-mango http://beta.quicklisp.org/archive/cl-mango/2020-09-25/cl-mango-20200925-git.tgz 102718 7f120c5a1186511963ac1f0d79839e06 0e2893031c03a5bd35e5ea34d283063fd7f07a28 cl-mango-20200925-git cl-mango.asd
cl-markdown http://beta.quicklisp.org/archive/cl-markdown/2019-12-27/cl-markdown-20191227-git.tgz 73424 630fdb2615d0c7cd7b31a5d6295ae552 eebe40f532720a42422ecfca77bbb2ef60ecfe19 cl-markdown-20191227-git cl-markdown-comparisons.asd cl-markdown-test.asd cl-markdown.asd
cl-markless http://beta.quicklisp.org/archive/cl-markless/2022-07-07/cl-markless-20220707-git.tgz 77115 625acb0ad58df3476a21acac878cceb0 a2fa25a76db4c85189e76e6a6aa53a3e0f443128 cl-markless-20220707-git cl-markless-test.asd cl-markless.asd epub/cl-markless-epub.asd markdown/cl-markless-markdown.asd plump/cl-markless-plump.asd standalone/cl-markless-standalone.asd
cl-marklogic http://beta.quicklisp.org/archive/cl-marklogic/2021-01-24/cl-marklogic-20210124-git.tgz 1814659 5af815613b7a90391fe6b8a0b1b4872a 53b10052d9476d0297819024f92600900984da1f cl-marklogic-20210124-git cl-marklogic.asd subsystem/ml-dsl/ml-dsl.asd subsystem/ml-optimizer/ml-optimizer.asd subsystem/ml-test/ml-test.asd
cl-markup http://beta.quicklisp.org/archive/cl-markup/2013-10-03/cl-markup-20131003-git.tgz 5785 3ec36b8e15435933f614959032987848 6aa4346b3ea4f1113934de898307229892252b12 cl-markup-20131003-git cl-markup-test.asd cl-markup.asd
cl-marshal http://beta.quicklisp.org/archive/cl-marshal/2022-11-06/cl-marshal-20221106-git.tgz 12404 567104e6dc6e91211aad977ef0b0e28b 309813beb581491e1b823a22a2cf04f268044958 cl-marshal-20221106-git marshal-tests.asd marshal.asd
cl-match http://beta.quicklisp.org/archive/cl-match/2012-11-25/cl-match-20121125-git.tgz 23798 790a315e08136b3e9b3a42eaadc558a4 a747badf5dabd5b345df787c4b5765ee1d7bbe78 cl-match-20121125-git cl-match-test.asd cl-match.asd pcl-unit-test.asd standard-cl.asd
cl-mathstats http://beta.quicklisp.org/archive/cl-mathstats/2022-02-20/cl-mathstats-20220220-git.tgz 83342 7003deec92a5fcfd4606b7b0f491f3ac 27133c7e7728a0b50adbe514cffd9290f3ade048 cl-mathstats-20220220-git cl-mathstats-test.asd cl-mathstats.asd
cl-maxminddb http://beta.quicklisp.org/archive/cl-maxminddb/2021-06-30/cl-maxminddb-20210630-git.tgz 7546 5d5d1346835e715ac6cfd130079448b2 5478ec1220f4f7d25bcefba438306ac5ff94a11d cl-maxminddb-20210630-git cl-maxminddb.asd
cl-maxsat http://beta.quicklisp.org/archive/cl-maxsat/2020-02-18/cl-maxsat-20200218-git.tgz 23748 d3a87dd7ed4354e80ed809a1f80a84be 2817cb160f759fdc66bf06b6fc1c9628d1b3c295 cl-maxsat-20200218-git cl-maxsat.asd cl-maxsat.test.asd
cl-mdb http://beta.quicklisp.org/archive/cl-mdb/2022-07-07/cl-mdb-20220707-git.tgz 15694 0b443f9fd77f7a3821de81011c48a387 f11330198af6b5b9bdabe46fa800b87088c95033 cl-mdb-20220707-git cl-mdb.asd
cl-mecab http://beta.quicklisp.org/archive/cl-mecab/2018-10-18/cl-mecab-20181018-git.tgz 2767 2ab93a1f4c43bab2428e5175108169a2 785e78ddcb996dc7d517f7796063d78f853c658c cl-mecab-20181018-git cl-mecab-test.asd cl-mecab.asd
cl-mechanize http://beta.quicklisp.org/archive/cl-mechanize/2018-07-11/cl-mechanize-20180711-git.tgz 3722 232d80473f28373048d93ca69f2b67a0 bfb4e5e0fcc4181fb4ba09c65c8b21e6bdafc9cc cl-mechanize-20180711-git cl-mechanize.asd
cl-mediawiki http://beta.quicklisp.org/archive/cl-mediawiki/2016-12-04/cl-mediawiki-20161204-git.tgz 16116 25991d3a28d94bf01f7a3a9464e2c3e9 5b3f1c43c010085a50b3459daec5b6b2fe16bd8a cl-mediawiki-20161204-git cl-mediawiki-test.asd cl-mediawiki.asd
cl-megolm http://beta.quicklisp.org/archive/cl-megolm/2021-10-20/cl-megolm-20211020-git.tgz 18933 7f381c1ebf7d6769eacc5dabcdb33b81 e7af4308e9046e7039831ee2f6be1823f9e91de8 cl-megolm-20211020-git cl-megolm.asd
cl-memcached http://beta.quicklisp.org/archive/cl-memcached/2015-06-08/cl-memcached-20150608-git.tgz 16575 d53b92973d51e95558aafaba56942c92 694deb82afc44290d593d4ca6d1242077af14fc9 cl-memcached-20150608-git cl-memcached.asd
cl-messagepack http://beta.quicklisp.org/archive/cl-messagepack/2020-10-16/cl-messagepack-20201016-git.tgz 11722 cd56b756012a71083838ac2e8846ea98 de3627c3a1113dcbacfe1f924e5cb2f253eb0629 cl-messagepack-20201016-git cl-messagepack-tests.asd cl-messagepack.asd
cl-messagepack-rpc http://beta.quicklisp.org/archive/cl-messagepack-rpc/2017-12-27/cl-messagepack-rpc-20171227-git.tgz 11177 6de2befbdd2a7e7ee028e0f9cc82bd7f 7b4c77bdb4dad0a365868591dbd75ad1ae3d4c10 cl-messagepack-rpc-20171227-git cl-messagepack-rpc-tests.asd cl-messagepack-rpc.asd
cl-migrations http://beta.quicklisp.org/archive/cl-migrations/2011-01-10/cl-migrations-20110110-http.tgz 3843 af513b9cd5bf182bd7c0910a98107823 cb5ae65cdda19f45cee7eaf4ad1726eddd3fd794 cl-migrations-20110110-http cl-migrations.asd
cl-migratum http://beta.quicklisp.org/archive/cl-migratum/2022-11-06/cl-migratum-20221106-git.tgz 887811 fc46af7bef028b3e98a387c5c327c7dd b6fcf014d8cdda7f9970d5d59bb7b6cb518e8fd3 cl-migratum-20221106-git cl-migratum.asd cl-migratum.cli.asd cl-migratum.driver.dbi.asd cl-migratum.driver.mixins.asd cl-migratum.driver.rdbms-postgresql.asd cl-migratum.provider.local-path.asd cl-migratum.test.asd
cl-mime http://beta.quicklisp.org/archive/cl-mime/2020-12-20/cl-mime-20201220-git.tgz 16952 1cfd9c5ccd0ee9fab358db47228d19ce 7136e1c4c5888b58a8499e16b003fe3146a8720b cl-mime-20201220-git cl-mime-test.asd cl-mime.asd
cl-mime-from-string http://beta.quicklisp.org/archive/cl-mime-from-string/2020-04-27/cl-mime-from-string-20200427-git.tgz 2441 dc30330e999d3fa93eba45b1b63d2f38 5e4c437b54faec0ddede2c88450eaa641dd369da cl-mime-from-string-20200427-git cl-mime-from-string.asd
cl-mimeparse http://beta.quicklisp.org/archive/cl-mimeparse/2021-05-31/cl-mimeparse-20210531-git.tgz 3890 0ed931e948aacc4b573e3e3a64ba62c9 243341c3827ec47fa91956c171dc8519b5547471 cl-mimeparse-20210531-git cl-mimeparse-tests.asd cl-mimeparse.asd
cl-minify-css http://beta.quicklisp.org/archive/cl-minify-css/2020-09-25/cl-minify-css-20200925-git.tgz 4753 382004d380c5a350c858aa4706c1625d 18682765f9edd38025102a33e64569132b27f155 cl-minify-css-20200925-git cl-minify-css-test.asd cl-minify-css.asd
cl-mixed http://beta.quicklisp.org/archive/cl-mixed/2022-11-06/cl-mixed-20221106-git.tgz 8960220 046335be4913e5e41947db510f2a0d8c d20e1e263342837a5365bcfad8d7b885dc4db4ef cl-mixed-20221106-git cl-mixed.asd examples/cl-mixed-examples.asd extensions/cl-mixed-alsa.asd extensions/cl-mixed-coreaudio.asd extensions/cl-mixed-flac.asd extensions/cl-mixed-jack.asd extensions/cl-mixed-mpg123.asd extensions/cl-mixed-mpt.asd extensions/cl-mixed-oss.asd extensions/cl-mixed-out123.asd extensions/cl-mixed-pulse.asd extensions/cl-mixed-sdl2.asd extensions/cl-mixed-vorbis.asd extensions/cl-mixed-wasapi.asd extensions/cl-mixed-wav.asd extensions/cl-mixed-winmm.asd extensions/cl-mixed-xaudio2.asd
cl-mlep http://beta.quicklisp.org/archive/cl-mlep/2018-04-30/cl-mlep-20180430-git.tgz 219387 378549be18c26b35a2a928b48f20e7c6 2e4e11c788b75de49c76163fb045d0741d33747e cl-mlep-20180430-git mlep-add.asd mlep.asd
cl-mock http://beta.quicklisp.org/archive/cl-mock/2022-11-06/cl-mock-20221106-git.tgz 7905 4a9326b1fc7c15944fefac544cdb9596 b0cca6b2bc21fca9755db04332f9c383270e009a cl-mock-20221106-git cl-mock-basic.asd cl-mock-tests-basic.asd cl-mock-tests.asd cl-mock.asd
cl-modlisp http://beta.quicklisp.org/archive/cl-modlisp/2015-09-23/cl-modlisp-20150923-git.tgz 10406 95f48447065e734ddfd23a58df53679b 5f92ef72be5b0897ed4ca226adbcbe9311a458bf cl-modlisp-20150923-git modlisp.asd
cl-monad-macros http://beta.quicklisp.org/archive/cl-monad-macros/2011-06-19/cl-monad-macros-20110619-svn.tgz 29833 8bff3b40a3720242b6f8f13932dd7b9e 46a54c95c093f7c263c8963479147624b3d234fd cl-monad-macros-20110619-svn cl-monad-macros.asd
cl-moneris http://beta.quicklisp.org/archive/cl-moneris/2011-04-18/cl-moneris-20110418-git.tgz 6676 ad2527ea7e6d8618757907dd2193224a 572b40deafdbd20a759bb36bc26250f6df64c8ac cl-moneris-20110418-git cl-moneris-test.asd cl-moneris.asd
cl-mongo http://beta.quicklisp.org/archive/cl-mongo/2016-05-31/cl-mongo-20160531-git.tgz 63737 f37c70b58ebbbc36dd855356b196c9a0 65b1c29c5c6bf02f9bbd7d64a260089968c41eec cl-mongo-20160531-git cl-mongo.asd
cl-mongo-id http://beta.quicklisp.org/archive/cl-mongo-id/2020-12-20/cl-mongo-id-20201220-git.tgz 3890 ba186c43306175a662568cfda32bb487 6e2d7c5f6a54174f8962101978285fb58d3d867c cl-mongo-id-20201220-git cl-mongo-id.asd
cl-monitors http://beta.quicklisp.org/archive/cl-monitors/2019-07-10/cl-monitors-20190710-git.tgz 30426 1c6c7f00915b0301a44f99eb5db282fe 6cbc22dbdf2b5dff91722aa12346e35a9a91f8c9 cl-monitors-20190710-git cl-monitors.asd
cl-mop http://beta.quicklisp.org/archive/cl-mop/2015-01-13/cl-mop-20150113-git.tgz 3524 2fafd8a889b9ad8455e0451d97a60f66 b6fd23f5ff74a7343158fcb9979362f24104a670 cl-mop-20150113-git cl-mop.asd
cl-morse http://beta.quicklisp.org/archive/cl-morse/2022-07-07/cl-morse-v1.0.0.tgz 5318 a9433acbc1a4e97596e0407dfab5efbb 0f4f1ddd6062f6b7c322f8f62b3650113ad7145a cl-morse-v1.0.0 cl-morse.asd
cl-moss http://beta.quicklisp.org/archive/cl-moss/2017-10-19/cl-moss-20171019-git.tgz 15420 5a242fbf7bc9a257a163dffd37467f1b 33a67534114561c248037d59806161a3c3281a05 cl-moss-20171019-git cl-moss.asd
cl-mount-info http://beta.quicklisp.org/archive/cl-mount-info/2020-02-18/cl-mount-info-20200218-git.tgz 22616 c280de944fab639bf2a75534a12635e5 ab0fee5243784b9c67ed8abb515779c923f44ce6 cl-mount-info-20200218-git cl-mount-info.asd
cl-mpg123 http://beta.quicklisp.org/archive/cl-mpg123/2021-12-09/cl-mpg123-20211209-git.tgz 1362634 3413cecda302c043aea37aa9ca4f7b49 adb9926a533b91baedf8271d5467d9f2690f3733 cl-mpg123-20211209-git cl-mpg123-example.asd cl-mpg123.asd
cl-mpi http://beta.quicklisp.org/archive/cl-mpi/2019-07-10/cl-mpi-20190710-git.tgz 29951 084a37f38bc915e7cb446f0d659e745c 6aec00040dd9c6d789642e78799a97f93bd15de3 cl-mpi-20190710-git cl-mpi-asdf-integration.asd cl-mpi-extensions.asd cl-mpi-test-suite.asd cl-mpi.asd examples/cl-mpi-examples.asd
cl-mssql http://beta.quicklisp.org/archive/cl-mssql/2021-01-24/cl-mssql-20210124-git.tgz 15817 6f103cdbc07c2ae284c7aa2038d29f71 6be09db3233b3e699ead9bd6cd66f4a8a3e88362 cl-mssql-20210124-git mssql.asd
cl-mtgnet http://beta.quicklisp.org/archive/cl-mtgnet/2018-07-11/cl-mtgnet-20180711-git.tgz 13584 552af7cb3547102849920f639964c694 91a94bf40fb828bc3c8353ca1a17bdc53b1d4960 cl-mtgnet-20180711-git cl-mtgnet-async.asd cl-mtgnet-sync.asd cl-mtgnet.asd
cl-murmurhash http://beta.quicklisp.org/archive/cl-murmurhash/2021-06-30/cl-murmurhash-20210630-git.tgz 6960 cae2ba02f37249b023fe2a053722d9b9 f8c1ccaa85767bfcfc2322b064b4af732eb756d9 cl-murmurhash-20210630-git cl-murmurhash.asd
cl-mustache http://beta.quicklisp.org/archive/cl-mustache/2020-03-25/cl-mustache-20200325-git.tgz 16325 52381d17458d88d6a8b760f351bf517d 39a5974599d0fc9ae6829087b99dbe7ec45150bd cl-mustache-20200325-git cl-mustache-test.asd cl-mustache.asd
cl-muth http://beta.quicklisp.org/archive/cl-muth/2022-07-07/cl-muth-stable-git.tgz 7447 67e4f582ac08a94fc3a93e8c9199f599 8edcf66e2d3d01e0558b30728c9d1248d24956e1 cl-muth-stable-git cl-muth.asd
cl-mw http://beta.quicklisp.org/archive/cl-mw/2015-04-07/cl-mw-20150407-git.tgz 89150 688397a73badb51c626bb5633cfbf9bb 4a3d5e5a5d6413396e759c0895838bc03f70b93d cl-mw-20150407-git cl-mw.asd cl-mw.examples.argument-processing.asd cl-mw.examples.hello-world.asd cl-mw.examples.higher-order.asd cl-mw.examples.monte-carlo-pi.asd cl-mw.examples.ping.asd cl-mw.examples.with-task-policy.asd
cl-myriam http://beta.quicklisp.org/archive/cl-myriam/2022-03-31/cl-myriam-20220331-git.tgz 9229 01fbad030cc9705a635a2082b9310891 cbeda608d72eb9f5d35b390797029965fc24dec9 cl-myriam-20220331-git cl-myriam.asd
cl-mysql http://beta.quicklisp.org/archive/cl-mysql/2020-06-10/cl-mysql-20200610-git.tgz 25756 05d5ed6b48edbafd258e189d7868822e c4239d0371c67029a812a7d8e08d434de8fc8c8d cl-mysql-20200610-git cl-mysql-test.asd cl-mysql.asd
cl-naive-store http://beta.quicklisp.org/archive/cl-naive-store/2022-11-06/cl-naive-store-20221106-git.tgz 96236 cb300d9386686c430179738487c2c50f 6bf84f261e9f72ec21186981c370db87f0395815 cl-naive-store-20221106-git cl-naive-store.asd cl-naive-store.document-type-defs.asd cl-naive-store.document-types.asd cl-naive-store.naive-core.asd cl-naive-store.naive-documents.asd cl-naive-store.naive-indexed.asd cl-naive-store.naive-merkle.asd cl-naive-store.test.asd
cl-ncurses http://beta.quicklisp.org/archive/cl-ncurses/2010-10-06/cl-ncurses_0.1.4.tgz 23603 60cde15b3c037f394e0c24eb55ad56f8 8d7cfd9bb56ba8c2e6f98bcb298bfc121f8d51bd cl-ncurses_0.1.4 cl-ncurses.asd
cl-neo4j http://beta.quicklisp.org/archive/cl-neo4j/2013-01-28/cl-neo4j-release-b8ad637a-git.tgz 9194 cb073877ef9a06784c7d1964e0c9266d f8a127e60e89f6a419ac4c59f4e734ce3f513258 cl-neo4j-release-b8ad637a-git cl-neo4j.asd
cl-neovim http://beta.quicklisp.org/archive/cl-neovim/2019-05-21/cl-neovim-20190521-git.tgz 28387 c74dc12e6ebcac2f55b0c5f510740734 a47dc4c6b386f74eb24f8370b14ebe489a70753c cl-neovim-20190521-git cl-neovim.asd
cl-netpbm http://beta.quicklisp.org/archive/cl-netpbm/2020-10-16/cl-netpbm-20201016-hg.tgz 406684 e308bcb4164efceb21e1a7415c76a530 9eed362a2038882360ad83fb669bf7df555c8d2f cl-netpbm-20201016-hg cl-netpbm.asd
cl-netstring-plus http://beta.quicklisp.org/archive/cl-netstring-plus/2015-07-09/cl-netstring-plus-20150709-git.tgz 4433 6e8765afb3524b15982841b1351e1f8c 21e3f577bcb812b607b5a1b180e97ee8763cf6c1 cl-netstring-plus-20150709-git cl-netstring+.asd
cl-netstrings http://beta.quicklisp.org/archive/cl-netstrings/2012-10-13/cl-netstrings-20121013-git.tgz 3736 8869774ca304843bb00041d63d80ba1e 9bf9f017e4e1b95c067e38c9fdc1e6db85a1457a cl-netstrings-20121013-git cl-netstrings.asd
cl-notebook http://beta.quicklisp.org/archive/cl-notebook/2020-12-20/cl-notebook-20201220-git.tgz 238241 070a26bcb1b8198e290d2fbd024abe16 b1d08a2c8ff0495cfb572e686900923d4473efb8 cl-notebook-20201220-git cl-notebook.asd
cl-nst http://beta.quicklisp.org/archive/cl-nst/2021-08-07/cl-nst-20210807-git.tgz 812877 6092e7a979643ce5ea7512fc8c114ee3 f4bbdd8059d1cda748cb0beed95ba66620587e5a cl-nst-20210807-git asdf-nst.asd nst.asd test/direct/nst-simple-tests.asd test/lisp/comp-set/comp-set.asd test/manual/nst-manual-tests.asd test/meta/mnst-relay.asd test/meta/nst-meta-tests.asd test/nst-test-jenkins.asd test/nst-test.asd test/util/nst-selftest-utils.asd utils/mop/nst-mop-utils.asd
cl-ntp-client http://beta.quicklisp.org/archive/cl-ntp-client/2021-06-30/cl-ntp-client-20210630-git.tgz 3476 a81466a5aec3a419f5e272850111fbd5 b817d0ac91a587c138a2b92dc4ae20e92a7ef8bd cl-ntp-client-20210630-git cl-ntp-client.asd
cl-ntriples http://beta.quicklisp.org/archive/cl-ntriples/2019-03-07/cl-ntriples-20190307-hg.tgz 6167 118afd8c0a65aad8e83e92f19e31117b e6bbc4ad2c50a998124d50ec4b8fdc8eb99f807a cl-ntriples-20190307-hg cl-ntriples.asd
cl-num-utils http://beta.quicklisp.org/archive/cl-num-utils/2021-05-31/cl-num-utils-20210531-git.tgz 64249 1977251bf552ba82005de0dc2f37d130 4c4dd4fb1555499a65813f0bb70673d849c1f4d2 cl-num-utils-20210531-git cl-num-utils.asd
cl-nxt http://beta.quicklisp.org/archive/cl-nxt/2015-06-08/cl-nxt-20150608-git.tgz 25121 a63efb53921dfb220e9085b7c67a989a c453129fbccbffe7dc25c77c1fe974b453d97b32 cl-nxt-20150608-git nxt-proxy.asd nxt.asd
cl-oauth http://beta.quicklisp.org/archive/cl-oauth/2015-08-04/cl-oauth-20150804-git.tgz 22871 280ca181aaf219d292dfcc5795d68b01 b2dcc9fde0faa4a38dc07d20f523182e0d6ccb21 cl-oauth-20150804-git cl-oauth.asd
cl-oclapi http://beta.quicklisp.org/archive/cl-oclapi/2018-08-31/cl-oclapi-20180831-git.tgz 17154 e80585c65e677f1ad10c5ae6b10879fd 1e73f38e41e931301d229a751cb8eb7e7bd2e27b cl-oclapi-20180831-git cl-oclapi-test.asd cl-oclapi.asd
cl-octet-streams http://beta.quicklisp.org/archive/cl-octet-streams/2020-12-20/cl-octet-streams-20201220-git.tgz 19408 a253df417a029475c4df9984cd458dd1 492e1711afc8b22be8fab6bcedfd7359c3029ffa cl-octet-streams-20201220-git cl-octet-streams.asd
cl-ode http://beta.quicklisp.org/archive/cl-ode/2016-06-28/cl-ode-20160628-git.tgz 10617 21c1ba1c91b5910a201cfb824c45fbf0 756649c7ff0912184bb0fa7c8a7e6abafc20273e cl-ode-20160628-git cl-ode.asd
cl-odesk http://beta.quicklisp.org/archive/cl-odesk/2015-06-08/cl-odesk-20150608-git.tgz 6930 e19a70b04c5f7204d46b7bd33a14e054 ab5f306a08b087e175dfe6389e1634444e147adb cl-odesk-20150608-git odesk.asd
cl-ohm http://beta.quicklisp.org/archive/cl-ohm/2018-02-28/cl-ohm-20180228-git.tgz 18129 988fa480a9196cd349782dfefb91b173 e18484324b8fdb9c372d0ad9aa3ebd150c328ec7 cl-ohm-20180228-git cl-ohm.asd
cl-oju http://beta.quicklisp.org/archive/cl-oju/2022-11-06/cl-oju-20221106-git.tgz 116804 8091fe8b8ecf429b4d5d399c46d6c9b3 dc6075548132278597eaf77eab6b23ed935a6ba7 cl-oju-20221106-git cl-oju.asd
cl-olefs http://beta.quicklisp.org/archive/cl-olefs/2015-07-09/cl-olefs-20150709-git.tgz 21367 e2051eb090625ecf6ef295bbee5e3f65 7dd0fb6d14d42fdb4d3f331c1f15770d8277eda4 cl-olefs-20150709-git cl-olefs.asd
cl-one-time-passwords http://beta.quicklisp.org/archive/cl-one-time-passwords/2017-10-19/cl-one-time-passwords-20171019-git.tgz 4901 c565262b547110b1d5528671483a6166 4b5b6788ed4c8c3b80d1d573779dfff638a30c9a cl-one-time-passwords-20171019-git cl-one-time-passwords-test.asd cl-one-time-passwords.asd
cl-online-learning http://beta.quicklisp.org/archive/cl-online-learning/2022-03-31/cl-online-learning-20220331-git.tgz 44540 ac898c7d202047375b45e2a7baf2bd6a b80163d2892cfd9d94176b8e8fa66478f11bd364 cl-online-learning-20220331-git cl-online-learning-test.asd cl-online-learning.asd
cl-openal http://beta.quicklisp.org/archive/cl-openal/2022-11-06/cl-openal-20221106-git.tgz 14293 4d9a68b6641b70977759b9d0ec31f729 adbf9aaadac9e0ce37b0978fbaa75de612b7e055 cl-openal-20221106-git cl-alc.asd cl-alut.asd cl-openal-examples.asd cl-openal.asd
cl-openapi-parser http://beta.quicklisp.org/archive/cl-openapi-parser/2021-06-30/cl-openapi-parser-20210630-git.tgz 158401 d4b9c0337735c0141588e26ca83e7ece 02b96432f9beac2292719ab6587a6baacd06d6c8 cl-openapi-parser-20210630-git openapi-parser.asd
cl-opencl http://beta.quicklisp.org/archive/cl-opencl/2021-12-09/cl-opencl-20211209-git.tgz 51292 bdd8acf5217c1c3690314b57c66920ae f947ae391ca202504cb5b972a2a42baa3feb41aa cl-opencl-20211209-git cl-opencl.asd
cl-opencl-utils http://beta.quicklisp.org/archive/cl-opencl-utils/2021-10-20/cl-opencl-utils-20211020-git.tgz 90252 9e50e95f0d7be9da49977640b532c4a7 424372af78ef336256ba14959128c562af17b555 cl-opencl-utils-20211020-git cl-opencl-utils.asd
cl-opengl http://beta.quicklisp.org/archive/cl-opengl/2019-11-30/cl-opengl-20191130-git.tgz 439215 c5387f051960e9179b2ed32fafb67e72 12c358b808eb731ea8519ef6bed602c3c7438cfa cl-opengl-20191130-git cl-glu.asd cl-glut-examples.asd cl-glut.asd cl-opengl.asd
cl-openstack-client http://beta.quicklisp.org/archive/cl-openstack-client/2019-10-07/cl-openstack-client-20191007-git.tgz 15217 21d5f62c63d36ec3b51bac01be54122c ac507feb7962ce6654e7c434f8abd3bfd59edad1 cl-openstack-client-20191007-git cl-openstack-client-test.asd cl-openstack-client.asd
cl-opsresearch http://beta.quicklisp.org/archive/cl-opsresearch/2017-04-03/cl-opsresearch-20170403-git.tgz 169006 3f9d2d4fa2e5bd0bd262c3e7d8473933 d5ec56c8385fdecddd862753f1941f476b6c4797 cl-opsresearch-20170403-git cl-opsresearch.asd subsystem/or-cluster/or-cluster.asd subsystem/or-fann/or-fann.asd subsystem/or-glpk/or-glpk.asd subsystem/or-gsl/or-gsl.asd subsystem/or-test/or-test.asd
cl-org-mode http://beta.quicklisp.org/archive/cl-org-mode/2010-12-07/cl-org-mode-20101207-git.tgz 16460 f4220fc89b86010c37f682b937e48758 4bb1c14e15eaacc107bbf539fc308766cd8f90d0 cl-org-mode-20101207-git cl-org-mode.asd
cl-out123 http://beta.quicklisp.org/archive/cl-out123/2019-07-10/cl-out123-20190710-git.tgz 793012 fe497cc028c073c1b28390c704a98e56 13f4bf99dd9d41f7f326f39c7d2acf561fc63b40 cl-out123-20190710-git cl-out123.asd
cl-pack http://beta.quicklisp.org/archive/cl-pack/2020-04-27/cl-pack-20200427-git.tgz 13687 bffd67704cedf806a38a5261c8bab02b 688bc0ea3248277b99ebe31dfb4fbb34adfaa97f cl-pack-20200427-git cl-pack.asd
cl-package-locks http://beta.quicklisp.org/archive/cl-package-locks/2011-12-03/cl-package-locks-20111203-git.tgz 3225 27ed43ed35ef89c3b1d7c5b2594f854c 1cb55bc796f5325a251868413e66a915596477cb cl-package-locks-20111203-git cl-package-locks.asd
cl-pango http://beta.quicklisp.org/archive/cl-pango/2017-04-03/cl-pango-20170403-git.tgz 14796 3a55e08abc5f99a853b80c835edb868d 3a8f8780b761e9f58b803a743928c98741be4a4c cl-pango-20170403-git cl-pango.asd
cl-parallel http://beta.quicklisp.org/archive/cl-parallel/2013-03-12/cl-parallel-20130312-git.tgz 3888 246f314b0ffa627a311e775b00dd0b65 b1d4c6defe936a70b5a9bbe431e94c65f8d0c023 cl-parallel-20130312-git cl-parallel.asd
cl-parser-combinators http://beta.quicklisp.org/archive/cl-parser-combinators/2013-11-11/cl-parser-combinators-20131111-git.tgz 36429 25ad9b1459901738a6394422a41b8fec a708a8b6996a18c3aed1d9d909f9c52477c72fba cl-parser-combinators-20131111-git parser-combinators-cl-ppcre.asd parser-combinators-debug.asd parser-combinators-tests.asd parser-combinators.asd
cl-pass http://beta.quicklisp.org/archive/cl-pass/2020-12-20/cl-pass-20201220-git.tgz 2712 765d4fa1ec380fe4eac3a998e3a8eaf0 6f47e1189e7993e7941b3b2ba9d63c9f717910f4 cl-pass-20201220-git cl-pass-test.asd cl-pass.asd
cl-pattern http://beta.quicklisp.org/archive/cl-pattern/2014-07-13/cl-pattern-20140713-git.tgz 5143 cf8e74def535c66a358df1ada9d89785 cab8b56cdf63e359614d33840ef2faa539b351f3 cl-pattern-20140713-git cl-pattern-benchmark.asd cl-pattern.asd
cl-patterns http://beta.quicklisp.org/archive/cl-patterns/2022-11-06/cl-patterns-20221106-git.tgz 158189 21333a371a9a0a70c14b198921b37577 8059bac15f2681a958760ca340c87d9bed53a5a9 cl-patterns-20221106-git cl-patterns.asd
cl-paymill http://beta.quicklisp.org/archive/cl-paymill/2013-11-11/cl-paymill-20131111-git.tgz 7224 1c240a7da7b22b55d16f7e6922191aa9 95e9052fb40ff1dbbf7925287e1e4f1409198e7a cl-paymill-20131111-git cl-paymill.asd
cl-paypal http://beta.quicklisp.org/archive/cl-paypal/2010-10-06/cl-paypal-20101006-git.tgz 1701376 b24dd8ccbdb60e1dd220076d8a5baa4d 9cf3a3bba7d5ff0feea25875639f6728ac5b2d6a cl-paypal-20101006-git cl-paypal.asd
cl-pcg http://beta.quicklisp.org/archive/cl-pcg/2020-10-16/cl-pcg-20201016-hg.tgz 11450 6e7d576b345bd56680220e3d3f16b8c3 aefd31f23dd5f2dd4517e9b2e25ae25d87fd8f7a cl-pcg-20201016-hg cl-pcg.asd cl-pcg.test.asd
cl-pdf http://beta.quicklisp.org/archive/cl-pdf/2022-11-06/cl-pdf-20221106-git.tgz 479033 0bd889227dd95e8359a592982979a510 ded5796a6ffba62b8ea94fdce92eb0a71196350b cl-pdf-20221106-git cl-pdf-parser.asd cl-pdf.asd
cl-peppol http://beta.quicklisp.org/archive/cl-peppol/2020-10-16/cl-peppol-20201016-git.tgz 1212057 00ec60c444446733de15d22b9a2d4c0f 32fb68492c61dd2f1da7faf5795f91f8bd7e5fea cl-peppol-20201016-git peppol.asd
cl-performance-tuning-helper http://beta.quicklisp.org/archive/cl-performance-tuning-helper/2013-06-15/cl-performance-tuning-helper-20130615-git.tgz 3639 79f43c12d4c35fc6ae10d28467fa5318 2ef8321821c30635eb0eedee03d9cba474b2f2c3 cl-performance-tuning-helper-20130615-git cl-performance-tuning-helper-test.asd cl-performance-tuning-helper.asd
cl-permutation http://beta.quicklisp.org/archive/cl-permutation/2021-12-09/cl-permutation-20211209-git.tgz 59123 3a8448b65b06d2232e84929304c3c72e 272b3402d2294cd1b10ac4713aad2ad8e555cc8c cl-permutation-20211209-git cl-permutation-examples.asd cl-permutation-tests.asd cl-permutation.asd
cl-photo http://beta.quicklisp.org/archive/cl-photo/2015-09-23/cl-photo-20150923-git.tgz 12618 1cdf69f41104fcfb0a4ae99a01023148 16a6d27a0e01fc224be9741fb6dd4f0d4a568ef3 cl-photo-20150923-git cl-photo-tests.asd cl-photo.asd
cl-pixman http://beta.quicklisp.org/archive/cl-pixman/2017-08-30/cl-pixman-20170830-git.tgz 11694 5c0938bdf43ebe65574e446b47353e33 77f127fb3a0e55b4814a9796390070c86cc9ee94 cl-pixman-20170830-git pixman.asd
cl-plplot http://beta.quicklisp.org/archive/cl-plplot/2018-02-28/cl-plplot-20180228-git.tgz 289049 e4ac142b064ed3b20bdedd18c602e2c7 21da728b21572839150f71995713c7d54690bd70 cl-plplot-20180228-git cl-plplot.asd
cl-plumbing http://beta.quicklisp.org/archive/cl-plumbing/2018-10-18/cl-plumbing-20181018-git.tgz 3296 835188b1879ae9ad323bafb9cca36c0f fe1c2c004ee5f93822ecb669486ab9c5d6137c88 cl-plumbing-20181018-git cl-plumbing-test.asd cl-plumbing.asd
cl-ply http://beta.quicklisp.org/archive/cl-ply/2015-05-05/cl-ply-20150505-git.tgz 5845 54d8a7725a43455cd4d49ad6e2f1552b 16e20f501dd49b7c965542ee799b6e17c285fdfd cl-ply-20150505-git cl-ply-test.asd cl-ply.asd
cl-png http://beta.quicklisp.org/archive/cl-png/2021-10-20/cl-png-20211020-git.tgz 8510323 2c6e6240a1d4165805ef2dfaa5cf8587 03adb21f48b4e39cb1a03a708a6f63a77dd967fe cl-png-20211020-git png.asd test/bmp-test.asd test/image-test.asd test/ops-test.asd test/png-test.asd
cl-poker-eval http://beta.quicklisp.org/archive/cl-poker-eval/2015-08-04/cl-poker-eval-20150804-git.tgz 15226 7771236a5bda08d88c85a4e33f30047d 5f1611423e82f6132b0ecbc1286f88083642566f cl-poker-eval-20150804-git cl-poker-eval.asd
cl-pop http://beta.quicklisp.org/archive/cl-pop/2011-04-18/cl-pop-20110418-http.tgz 50142 95c0c3418f4740938467514787857bf7 2f413630bb3a0bd507e7a6314f7063f8415c64eb cl-pop-20110418-http cl-pop.asd
cl-portaudio http://beta.quicklisp.org/archive/cl-portaudio/2020-12-20/cl-portaudio-20201220-git.tgz 261400 8d98da3b25ccd9a3e2772720ab6c2462 ff0b63117fbc811f1a7b3c4225735fc683854a2a cl-portaudio-20201220-git cl-portaudio.asd
cl-portmanteau http://beta.quicklisp.org/archive/cl-portmanteau/2018-10-18/cl-portmanteau-20181018-git.tgz 4041 69dc35a5efd5a58644a86291f114d0ae 1873a59021da676c57cb60a8624ca62231445ab4 cl-portmanteau-20181018-git portmanteau-tests.asd portmanteau.asd
cl-postgres-datetime http://beta.quicklisp.org/archive/cl-postgres-datetime/2019-05-21/cl-postgres-datetime-20190521-git.tgz 2835 2a8346142cf960438f21504a76b48f14 45becc2cce71b8582c605e5727c51f650d3fdf11 cl-postgres-datetime-20190521-git cl-postgres-datetime.asd
cl-postgres-plus-uuid http://beta.quicklisp.org/archive/cl-postgres-plus-uuid/2018-10-18/cl-postgres-plus-uuid-20181018-git.tgz 2270 2fe4f3d80a987192c303695d8629f522 4ca2391fa2cf146d789969453d066da82962af5d cl-postgres-plus-uuid-20181018-git cl-postgres-plus-uuid.asd
cl-ppcre http://beta.quicklisp.org/archive/cl-ppcre/2022-02-20/cl-ppcre-20220220-git.tgz 157392 dfc08fa8887d446fb0d7f243c1b4e757 a8d12908ba943bba2c1aa164b723a7091db6c55d cl-ppcre-20220220-git cl-ppcre-unicode.asd cl-ppcre.asd
cl-prevalence http://beta.quicklisp.org/archive/cl-prevalence/2021-05-31/cl-prevalence-20210531-git.tgz 23584 4d2ced14365fb45ef97621298fd24501 be2f66b1175782ed5d627916532e8fcdb07ce1df cl-prevalence-20210531-git cl-prevalence-test.asd cl-prevalence.asd
cl-primality http://beta.quicklisp.org/archive/cl-primality/2015-06-08/cl-primality-20150608-git.tgz 5079 e1590227314e5b4edee345232e8a4904 7698c3bcc32494cc4acf4ee91166745160668904 cl-primality-20150608-git cl-primality-test.asd cl-primality.asd
cl-prime-maker http://beta.quicklisp.org/archive/cl-prime-maker/2015-03-02/cl-prime-maker-20150302-git.tgz 5286 018c603dd74eb6a2f760188c1e9e581b b25b00051812d0c302e0e894dd3f3b6cb57cb4c9 cl-prime-maker-20150302-git cl-prime-maker.asd
cl-progress-bar http://beta.quicklisp.org/archive/cl-progress-bar/2021-12-09/cl-progress-bar-20211209-git.tgz 3522 6089995e48ae25b4eaeca0f0bc6ed095 e108094902031042d1e26414b648980234225e11 cl-progress-bar-20211209-git cl-progress-bar.asd
cl-project http://beta.quicklisp.org/archive/cl-project/2020-07-15/cl-project-20200715-git.tgz 5355 12b436050ad0106cf292707ae39d8572 c77e92bb67d6e56713ed3ae6ee61a34e35f8ed2b cl-project-20200715-git cl-project-test.asd cl-project.asd
cl-prolog2 http://beta.quicklisp.org/archive/cl-prolog2/2021-12-09/cl-prolog2-20211209-git.tgz 15659 e9641fa18abc28b46ca6e4dee2916dca 3c50cad409ffa024fd1ee5db0dc56239dea2c767 cl-prolog2-20211209-git bprolog/cl-prolog2.bprolog.asd bprolog/cl-prolog2.bprolog.test.asd cl-prolog2.asd cl-prolog2.test.asd gprolog/cl-prolog2.gprolog.asd gprolog/cl-prolog2.gprolog.test.asd swi/cl-prolog2.swi.asd swi/cl-prolog2.swi.test.asd xsb/cl-prolog2.xsb.asd xsb/cl-prolog2.xsb.test.asd yap/cl-prolog2.yap.asd yap/cl-prolog2.yap.test.asd
cl-protobufs http://beta.quicklisp.org/archive/cl-protobufs/2022-11-06/cl-protobufs-20221106-git.tgz 196883 238ed9e6971e6529949ed47290d1aaf0 cce8670b02ecc7c7fc6339cedf3394d3b99a71e8 cl-protobufs-20221106-git cl-protobufs.asd cl-protobufs.asdf.asd
cl-pslib http://beta.quicklisp.org/archive/cl-pslib/2020-10-16/cl-pslib-20201016-git.tgz 42242 7e67250359d9b8627713b8587d25aae4 89a5f22d756264b4378bd0e86c79a8623889a943 cl-pslib-20201016-git cl-pslib.asd
cl-pslib-barcode http://beta.quicklisp.org/archive/cl-pslib-barcode/2020-02-18/cl-pslib-barcode-20200218-git.tgz 26694 52a2ffba62a8aeba001f4a7a11e6b13a 94fdf0e1d1e62c5fd92fe0795a93aed147f2ab10 cl-pslib-barcode-20200218-git cl-pslib-barcode.asd
cl-punch http://beta.quicklisp.org/archive/cl-punch/2019-01-07/cl-punch-20190107-git.tgz 1994 b5c6400872ae19221bf5a17f34750c63 e85b56b80563b86ab01b174561df88628c1ece7e cl-punch-20190107-git cl-punch-test.asd cl-punch.asd
cl-python http://beta.quicklisp.org/archive/cl-python/2022-03-31/cl-python-20220331-git.tgz 236951 19038fa121fdb056582fc8484a37dd7a 0cae2e7e3d209edc7fde8752a819ea12044ae242 cl-python-20220331-git clpython.asd
cl-qprint http://beta.quicklisp.org/archive/cl-qprint/2015-08-04/cl-qprint-20150804-git.tgz 33969 74376a69e0b078724c94cc268f69e0f7 2e2600e7a6ea7c1c21df10f3fb37a531fa1c9382 cl-qprint-20150804-git cl-qprint.asd
cl-qrencode http://beta.quicklisp.org/archive/cl-qrencode/2019-10-07/cl-qrencode-20191007-git.tgz 31145 e94ac1137949ef70dea11ca78431e956 0e6589fa846a65032275cbb576bc13d194476b8f cl-qrencode-20191007-git cl-qrencode-test.asd cl-qrencode.asd
cl-quickcheck http://beta.quicklisp.org/archive/cl-quickcheck/2020-06-10/cl-quickcheck-20200610-git.tgz 18441 92d8128d3014a06d38fddab32cc7d81d eac4c89caa498e2351afc73d839a2a9308204cd4 cl-quickcheck-20200610-git cl-quickcheck.asd
cl-rabbit http://beta.quicklisp.org/archive/cl-rabbit/2021-04-11/cl-rabbit-20210411-git.tgz 23616 d37c9fddab8847811a07c352e978dd38 d1e8e5edeae17ba97b888759161319b6fa373650 cl-rabbit-20210411-git cl-rabbit-tests.asd cl-rabbit.asd
cl-rail http://beta.quicklisp.org/archive/cl-rail/2017-12-27/cl-rail-20171227-git.tgz 3644 7da276363c4b689b0bfd85edb449b5d2 95cfb2281dd525f4e6597364a7896022dc715939 cl-rail-20171227-git rail.asd
cl-randist http://beta.quicklisp.org/archive/cl-randist/2022-11-06/cl-randist-20221106-git.tgz 29341 ecdd83f2cdc5ff15fc967387d150a357 d26242a1b0e076ce3806415afecd009348ee3c57 cl-randist-20221106-git cl-randist.asd
cl-random http://beta.quicklisp.org/archive/cl-random/2018-03-28/cl-random-20180328-git.tgz 47082 0f302ea0cf77c5120e85cda903a1026e 46bc508532878a29dfc9cd99fe61c0e18c9c88cc cl-random-20180328-git cl-random.asd
cl-random-forest http://beta.quicklisp.org/archive/cl-random-forest/2022-11-06/cl-random-forest-20221106-git.tgz 73689 69e19ab6eb843002915e7f1e2aa42ebe 99a1061851916827d9bb8ec9388d51586b55654a cl-random-forest-20221106-git cl-random-forest-test.asd cl-random-forest.asd
cl-rashell http://beta.quicklisp.org/archive/cl-rashell/2022-07-07/cl-rashell-20220707-git.tgz 34089 8c9696d4277888612ad998d454988f46 d83686621081d03a33fe863afd686df380f3b766 cl-rashell-20220707-git org.melusina.rashell.asd
cl-rcfiles http://beta.quicklisp.org/archive/cl-rcfiles/2011-12-03/cl-rcfiles-20111203-http.tgz 1905 c6d90a1fe1488fba48dfc8174e829c63 58fbfde7a9339e3129ab1f67da5da7fbe13a493d cl-rcfiles-20111203-http com.dvlsoft.rcfiles.asd
cl-rdfxml http://beta.quicklisp.org/archive/cl-rdfxml/2014-07-13/cl-rdfxml-20140713-git.tgz 24185 ec6e7be8c793352109ab0b633c67c9b8 c27a5bb25404175ec960dccb0805fe8ff82caf5e cl-rdfxml-20140713-git cl-rdfxml.asd
cl-rdkafka http://beta.quicklisp.org/archive/cl-rdkafka/2020-12-20/cl-rdkafka-20201220-git.tgz 57232 efe370913002b11fc2f48997ebe7fe5e 2caaed2b03bad51f10f076f69160153692685604 cl-rdkafka-20201220-git cl-rdkafka.asd
cl-readline http://beta.quicklisp.org/archive/cl-readline/2022-07-07/cl-readline-20220707-git.tgz 74428 2b9d3e671a2396eb269112b44f5748f3 e6d0ee5abd675e5341bc33978d07acddb2aca107 cl-readline-20220707-git cl-readline.asd
cl-recaptcha http://beta.quicklisp.org/archive/cl-recaptcha/2015-06-08/cl-recaptcha-20150608-git.tgz 2351 02198a25a246df0e1d2326d5a46bb9bb 127298018d8364bbc2b8c6763c772eef5d55651d cl-recaptcha-20150608-git cl-recaptcha.asd
cl-redis http://beta.quicklisp.org/archive/cl-redis/2020-09-25/cl-redis-20200925-git.tgz 25565 25db6600a0c90c66c7b0718ac921664d 934965550589140846275ba86e36eb5d2e99818b cl-redis-20200925-git cl-redis.asd
cl-reexport http://beta.quicklisp.org/archive/cl-reexport/2021-02-28/cl-reexport-20210228-git.tgz 2538 e083a9c49fe39d65f1ff7743eebe37c2 8b85c2ce95d178aa2deab798f8fc16dd4a0de6da cl-reexport-20210228-git cl-reexport-test.asd cl-reexport.asd
cl-renderdoc http://beta.quicklisp.org/archive/cl-renderdoc/2020-09-25/cl-renderdoc-20200925-git.tgz 65861 047d4526bf0d9127e70347a2ceb5fb47 fdde29c8bd85a7e6133748fd84c7fb9fb6dfb6bb cl-renderdoc-20200925-git cl-renderdoc.asd
cl-replica http://beta.quicklisp.org/archive/cl-replica/2022-11-06/cl-replica-20221106-git.tgz 81327 0c7e4b0738db6cd5141a0a2c871b12f3 12aa770ceeee3e12c50044f25b737636f44f4932 cl-replica-20221106-git cl-replica.asd
cl-rethinkdb http://beta.quicklisp.org/archive/cl-rethinkdb/2016-08-25/cl-rethinkdb-20160825-git.tgz 32793 b08605b7cfdc8351472c3764c1c86120 2d087d3e621659974f63a6c3a5fb28c1f22244bc cl-rethinkdb-20160825-git cl-rethinkdb-test.asd cl-rethinkdb.asd
cl-rfc2047 http://beta.quicklisp.org/archive/cl-rfc2047/2015-08-04/cl-rfc2047-20150804-git.tgz 6167 18e4a78b37f0b6bfb650907cb1dc8a17 4554d0124034923310e5134da555a5ac86c810e8 cl-rfc2047-20150804-git cl-rfc2047.asd test/cl-rfc2047-test.asd
cl-rfc4251 http://beta.quicklisp.org/archive/cl-rfc4251/2021-05-31/cl-rfc4251-20210531-git.tgz 11348 3a78cc42bd091e4572f7764237c2fe57 c02b8db86e86a3776173c09cb1081ee6af990bfa cl-rfc4251-20210531-git cl-rfc4251.asd cl-rfc4251.test.asd
cl-riff http://beta.quicklisp.org/archive/cl-riff/2022-07-07/cl-riff-20220707-git.tgz 4389 01abfb4455e1b533a3798f361c4d69bf 6bfc4c890d3f8bdbdb7ae95544322219b39eeedc cl-riff-20220707-git cl-riff.asd
cl-rlimit http://beta.quicklisp.org/archive/cl-rlimit/2015-06-08/cl-rlimit-20150608-git.tgz 3785 ea8d2343b95011bce0de3b699adf0cee 96e1fb8e23a5ad62b865930843dd6150488b8d84 cl-rlimit-20150608-git cl-rlimit.asd
cl-rmath http://beta.quicklisp.org/archive/cl-rmath/2018-03-28/cl-rmath-20180328-git.tgz 5219 0a7e999618e9381b458fea9703774f45 eb85ac5db3f73bba9f919287232e4ea895354424 cl-rmath-20180328-git cl-rmath.asd
cl-rollback http://beta.quicklisp.org/archive/cl-rollback/2022-11-06/cl-rollback-20221106-git.tgz 1254 fa5a83038dbbc8fa5dc29fc716dcfefc b4aaa97e604386ec81a8bac49e3b6e88e9f30949 cl-rollback-20221106-git rollback.asd
cl-routes http://beta.quicklisp.org/archive/cl-routes/2017-01-24/cl-routes-20170124-git.tgz 16959 00cf290e3908eae5cfe4291da87fb7ec b6cf44512de1794cd364a428bd184b9663e8dfc6 cl-routes-20170124-git routes.asd
cl-rrd http://beta.quicklisp.org/archive/cl-rrd/2013-01-28/cl-rrd-20130128-git.tgz 6990 6ed1292cb978445d9952e464d547d149 e820e55875b893f4014ae7358768e480f0d1a28c cl-rrd-20130128-git cl-rrd.asd
cl-rrt http://beta.quicklisp.org/archive/cl-rrt/2020-09-25/cl-rrt-20200925-git.tgz 122680 375bf057c3c4d1ebe84ec47d0bb30cb5 cd9e746941a339298e2b95500ba52c34a409231f cl-rrt-20200925-git cl-rrt.asd cl-rrt.benchmark.asd cl-rrt.rtree.asd cl-rrt.test.asd
cl-rss http://beta.quicklisp.org/archive/cl-rss/2020-10-16/cl-rss-20201016-git.tgz 6522 0c4437458cfef444a248319054e04e5b 2fe0df2b1aa1f6f98985b51bbceeda6db78208c5 cl-rss-20201016-git rss.asd
cl-rsvg2 http://beta.quicklisp.org/archive/cl-rsvg2/2020-09-25/cl-rsvg2-20200925-git.tgz 52983 1f7b33d377c92630a40bf21c2d9b8876 b60605b3b2edfde9f1981579cbdbc2a1cf46da11 cl-rsvg2-20200925-git cl-rsvg2-pixbuf.asd cl-rsvg2-test.asd cl-rsvg2.asd
cl-rules http://beta.quicklisp.org/archive/cl-rules/2019-07-10/cl-rules-20190710-git.tgz 19882 1630f82d032594f14e3eb73afa7cca02 30a3aa278f1df25ed0279dd26a755164d559c2e3 cl-rules-20190710-git cl-rules-test.asd cl-rules.asd
cl-s3 http://beta.quicklisp.org/archive/cl-s3/2013-01-28/cl-s3-20130128-git.tgz 5843 4d064571012b9604f35d38b54d394357 07603d2daf79010091a344f9818c07b435c2d5f2 cl-s3-20130128-git cl-s3.asd
cl-sam http://beta.quicklisp.org/archive/cl-sam/2015-06-08/cl-sam-20150608-git.tgz 4054488 63b1c3bb023e3ef06e5f3855e6144b24 b3e8816022b2cbed60171db86596242905c0edf3 cl-sam-20150608-git cl-sam-test.asd cl-sam.asd
cl-sandbox http://beta.quicklisp.org/archive/cl-sandbox/2018-01-31/cl-sandbox-20180131-git.tgz 6539 86be3668d5ac97547a5043a48f155303 fc1e5b23275df9e8fadea34ac67a19a52b6e1073 cl-sandbox-20180131-git cl-sandbox.asd
cl-sane http://beta.quicklisp.org/archive/cl-sane/2015-06-08/cl-sane-20150608-git.tgz 9398 eb13c4f10552e26bc25a3a262416b71d c956a99e26239fb1c7a7646a9372c1fe7d616c24 cl-sane-20150608-git sane.asd
cl-sanitize http://beta.quicklisp.org/archive/cl-sanitize/2013-07-20/cl-sanitize-20130720-git.tgz 14858 704397eb4bfd6eef71f7bdbba5a672bf 2cf5ca23dcb811cad0796d45ee062d30cc4ad682 cl-sanitize-20130720-git sanitize.asd
cl-sasl http://beta.quicklisp.org/archive/cl-sasl/2019-05-21/cl-sasl-v0.3.2.tgz 7083 61105fc8faf396a39fc9d9c3400b3c21 bed7a2a1a1908c83f5ee47d8d698aba828a12d83 cl-sasl-v0.3.2 cl-sasl.asd
cl-sat http://beta.quicklisp.org/archive/cl-sat/2022-07-07/cl-sat-20220707-git.tgz 19645 3dc71f95474cdbbea86eedaf26cddc02 7f133e25861fc3407493dfb7987aa86e7666a066 cl-sat-20220707-git cl-sat.asd cl-sat.test.asd
cl-sat.glucose http://beta.quicklisp.org/archive/cl-sat.glucose/2022-03-31/cl-sat.glucose-20220331-git.tgz 2992 4f4194884ed657459298c13bc735dd08 b0836e01eeb4c2f20ab2da3db03bca1b1b2ac476 cl-sat.glucose-20220331-git cl-sat.glucose.asd cl-sat.glucose.test.asd
cl-sat.minisat http://beta.quicklisp.org/archive/cl-sat.minisat/2022-03-31/cl-sat.minisat-20220331-git.tgz 2934 96395076d4d1a831e9c4ea21b8f9f065 77ca3a18ac76d70b63e197281c2e5da16f7abfa3 cl-sat.minisat-20220331-git cl-sat.minisat.asd cl-sat.minisat.test.asd
cl-scram http://beta.quicklisp.org/archive/cl-scram/2015-09-23/cl-scram-20150923-git.tgz 5503 a010b20d5532a08fc85c2c532ddea09f 3e7475151f474a9d54817daebef5590da99a78a1 cl-scram-20150923-git cl-scram.asd
cl-scribd http://beta.quicklisp.org/archive/cl-scribd/2013-03-12/cl-scribd-20130312-git.tgz 3363 b87c90e9a765d543c2edf464479d5f88 c7995da5ad011d99cd74fee78889138678cf71d2 cl-scribd-20130312-git cl-scribd.asd
cl-scripting http://beta.quicklisp.org/archive/cl-scripting/2021-10-20/cl-scripting-20211020-git.tgz 3843 2a8366718010644a12952a977f687d31 b56d960acee0ae374f0593ecb72c6900dacb5213 cl-scripting-20211020-git cl-scripting.asd
cl-scrobbler http://beta.quicklisp.org/archive/cl-scrobbler/2011-11-05/cl-scrobbler-20111105-git.tgz 10687 367d3741fc72df62a122ef7188117409 e14659ef82c2107a42ae6767c3137597a72202c1 cl-scrobbler-20111105-git cl-scrobbler.asd
cl-scsu http://beta.quicklisp.org/archive/cl-scsu/2022-11-06/cl-scsu-20221106-git.tgz 19639 13142f71faf99d80453b441181f58d33 b14a75e3895d7b0e6d7cb74af088819944426e25 cl-scsu-20221106-git cl-scsu-test.asd cl-scsu.asd
cl-sdl2 http://beta.quicklisp.org/archive/cl-sdl2/2022-07-07/cl-sdl2-20220707-git.tgz 2367082 d29e9392170b25b222e11a0a46a1a507 ecaf53a1cb509c20f05697773c9b25b830e4996f cl-sdl2-20220707-git sdl2.asd
cl-sdl2-image http://beta.quicklisp.org/archive/cl-sdl2-image/2019-02-02/cl-sdl2-image-20190202-git.tgz 400442 d0771409506b37b0f56d0258396d31fd da0dd9f2ca73880afd6303d6f9a616ce976ce486 cl-sdl2-image-20190202-git sdl2-image.asd
cl-sdl2-mixer http://beta.quicklisp.org/archive/cl-sdl2-mixer/2021-10-20/cl-sdl2-mixer-20211020-git.tgz 365217 c719972d551e4165226449cc97bed859 aad7588382c4809113734163dfdbd62faa1b39f1 cl-sdl2-mixer-20211020-git sdl2-mixer.asd
cl-sdl2-ttf http://beta.quicklisp.org/archive/cl-sdl2-ttf/2020-09-25/cl-sdl2-ttf-20200925-git.tgz 857286 473f22516691eb827d1b692ab9100c2a 14881e14abe06993b816a523d00c8286d58c1f91 cl-sdl2-ttf-20200925-git sdl2-ttf-examples.asd sdl2-ttf.asd
cl-secp256k1 http://beta.quicklisp.org/archive/cl-secp256k1/2022-07-07/cl-secp256k1-20220707-git.tgz 20393 90907d080046dedf1b03911f76d62c38 a18d4642779ebc3837ad9da2ac5adf09db26fec6 cl-secp256k1-20220707-git secp256k1.asd
cl-selenium http://beta.quicklisp.org/archive/cl-selenium/2016-05-31/cl-selenium-20160531-git.tgz 15740 308b72c1bdad85a13bf79803c822ee95 9fa23dcb879cab1c8894e0bf8e207490c5acd8a3 cl-selenium-20160531-git selenium.asd
cl-selenium-webdriver http://beta.quicklisp.org/archive/cl-selenium-webdriver/2018-03-28/cl-selenium-webdriver-20180328-git.tgz 7935 d9ee1973788ddfd81380a33495c4ec85 1b90f0da0d3ce8d74e408be28b2c4884b7885b2a cl-selenium-webdriver-20180328-git cl-selenium-test.asd cl-selenium.asd
cl-semver http://beta.quicklisp.org/archive/cl-semver/2022-11-06/cl-semver-20221106-git.tgz 5810 cf72236c14c38e21d1a58cc3fbabe5c7 4c714a6dd263ec8e6a7eac6374a0e17f3221a5d2 cl-semver-20221106-git cl-semver-test.asd cl-semver.asd
cl-sendgrid http://beta.quicklisp.org/archive/cl-sendgrid/2022-11-06/cl-sendgrid-20221106-git.tgz 3263 8474e2d5b0a4779a682acefb2f02cb99 c4793572a66a69715d905f298b1b98aaf6998d6c cl-sendgrid-20221106-git sendgrid.asd
cl-sentiment http://beta.quicklisp.org/archive/cl-sentiment/2013-01-28/cl-sentiment-20130128-git.tgz 15819 2f3445dffa9105370751fa8ba7c2005c fc4a0651df4d453162919d5bd43540cba491c81e cl-sentiment-20130128-git cl-sentiment.asd
cl-sentry-client http://beta.quicklisp.org/archive/cl-sentry-client/2022-11-06/cl-sentry-client-20221106-git.tgz 304954 07bb7a1f39379d134524f363e4513e9d 8a2876f14c309ea334fc16393652ee6ea6160625 cl-sentry-client-20221106-git sentry-client.asd sentry-client.async.asd sentry-client.hunchentoot.asd
cl-ses4 http://beta.quicklisp.org/archive/cl-ses4/2022-11-06/cl-ses4-20221106-git.tgz 9522 4d64798d6468c39efa5be808f9d0ca5d cfc2b9138b51f9c0b033ffcd26d0993a4c14c65a cl-ses4-20221106-git cl-ses4.asd
cl-setlocale http://beta.quicklisp.org/archive/cl-setlocale/2020-12-20/cl-setlocale-20201220-git.tgz 3225 d16f5c254bb586327252d62932944077 9cebee588026dc3969cf7f7ab623048edb209df4 cl-setlocale-20201220-git cl-setlocale.asd
cl-sha1 http://beta.quicklisp.org/archive/cl-sha1/2021-08-07/cl-sha1-20210807-git.tgz 3142 a7c9925c44d59bb213ff6508a5f49aa8 fd995e55cc0a1750300dfdc6934b7b6f79bbdcd9 cl-sha1-20210807-git cl-sha1.asd
cl-shellwords http://beta.quicklisp.org/archive/cl-shellwords/2015-09-23/cl-shellwords-20150923-git.tgz 3943 c2c62c6a2ce4ed2590d60707ead2e084 e925f0d8cc96238116bc7f29b75eb3572e9ce325 cl-shellwords-20150923-git cl-shellwords-test.asd cl-shellwords.asd
cl-shlex http://beta.quicklisp.org/archive/cl-shlex/2021-04-11/cl-shlex-20210411-git.tgz 8630 55446789d751206cc229ae876b7f57ac 5008d39adb43dc1f46519d47c3bc93b6b8f60b66 cl-shlex-20210411-git shlex.asd
cl-simple-concurrent-jobs http://beta.quicklisp.org/archive/cl-simple-concurrent-jobs/2015-05-05/cl-simple-concurrent-jobs-20150505-git.tgz 4297 01612838d9d398b13eec9a5b0bc28abb ebe1febd1180f311c340458960719d74cb8bda21 cl-simple-concurrent-jobs-20150505-git cl-simple-concurrent-jobs.asd
cl-simple-fsm http://beta.quicklisp.org/archive/cl-simple-fsm/2020-02-18/cl-simple-fsm-20200218-git.tgz 3582 fad71a6781c41751cefc38e92fed9b76 a2c7e7baad51f73989f26a58cf5ea327fa7ced85 cl-simple-fsm-20200218-git finite-state-machine.asd
cl-simple-table http://beta.quicklisp.org/archive/cl-simple-table/2013-03-12/cl-simple-table-20130312-git.tgz 5746 6b100dbdefa432b04a9dd2b36a7aa47b 701fddeefc3cbb1220fc31f7fcbd56294c7aa2a2 cl-simple-table-20130312-git cl-simple-table.asd
cl-singleton-mixin http://beta.quicklisp.org/archive/cl-singleton-mixin/2015-05-05/cl-singleton-mixin-20150505-git.tgz 2088 dbe6e7e009c5051cb4920e9965eff799 20a7748134ec477d642afc98e2a6117e817f8588 cl-singleton-mixin-20150505-git cl-singleton-mixin-test.asd cl-singleton-mixin.asd
cl-skip-list http://beta.quicklisp.org/archive/cl-skip-list/2022-07-07/cl-skip-list-20220707-git.tgz 13179 6dd7e99ffefceda9d8e8519a4c6aaa0e 1c1411e81b4a945a42a8e2251b51b56a3bab4f2e cl-skip-list-20220707-git cl-skip-list.asd
cl-skkserv http://beta.quicklisp.org/archive/cl-skkserv/2020-12-20/cl-skkserv-20201220-git.tgz 1807422 42cebf0c6a0719ad8e18224f89a39c4c 10fb0e4c195de0dbbeb8c746825aa6a7729fe404 cl-skkserv-20201220-git cl-skkserv.asd
cl-sl4a http://beta.quicklisp.org/archive/cl-sl4a/2015-08-04/cl-sl4a-20150804-git.tgz 1951 dbfee5c96a7f36682929591319236b24 346a2d6dd6942fa65cd5326a15d127b86a3a99b3 cl-sl4a-20150804-git cl-android.asd
cl-slice http://beta.quicklisp.org/archive/cl-slice/2021-05-31/cl-slice-20210531-git.tgz 7622 d7be90ed28b5c316b1f31b4f567bd725 5665df8d1d7752f16be3ac9d851ee67cf72eb402 cl-slice-20210531-git cl-slice.asd
cl-slp http://beta.quicklisp.org/archive/cl-slp/2014-08-26/cl-slp-20140826-git.tgz 7716 24dfaadf60cd54dfa811aa9d4e37d07e 0e6a27441f94c6e6ce46e0aead20fc9b2db4dfc7 cl-slp-20140826-git cl-slp.asd
cl-slug http://beta.quicklisp.org/archive/cl-slug/2018-02-28/cl-slug-20180228-git.tgz 7416 2b59b63bb9a234cb14959fda6f12fa2e 9512dd1601d8bcc265598fe6e49cdddf772eeb8f cl-slug-20180228-git cl-slug-test.asd cl-slug.asd
cl-smt-lib http://beta.quicklisp.org/archive/cl-smt-lib/2022-03-31/cl-smt-lib-20220331-git.tgz 4983 f3fd3a27a41bee736f4ce9eb73f4672b a4062da7a9b258e0a6aa2183c0945024e26b4f1e cl-smt-lib-20220331-git cl-smt-lib.asd
cl-smtp http://beta.quicklisp.org/archive/cl-smtp/2021-02-28/cl-smtp-20210228-git.tgz 37478 e2f9137807f80514e0433bf2e8522ee5 1fbda947e90501ff57ba1ac685bf5d5716e64d59 cl-smtp-20210228-git cl-smtp.asd
cl-soil http://beta.quicklisp.org/archive/cl-soil/2018-08-31/cl-soil-release-quicklisp-f27087ce-git.tgz 330400 e26e1e23f2a4bf10a4e4d7c8e2fcd70c 6d7ad0c6aef48bb614d85a709222afcefa75c692 cl-soil-release-quicklisp-f27087ce-git cl-soil.asd
cl-soloud http://beta.quicklisp.org/archive/cl-soloud/2019-07-10/cl-soloud-20190710-git.tgz 521503 59b094adf83863dbf491001ec9dc0e33 f028ca7c4cbc2c3aa86a4341fdeb61e3d9482db4 cl-soloud-20190710-git cl-soloud.asd
cl-sophia http://beta.quicklisp.org/archive/cl-sophia/2015-06-08/cl-sophia-20150608-git.tgz 5748 4fa639f26d38c37be18c0d4e0da4b153 186948212d713ac7bac820f476e63a372b591b69 cl-sophia-20150608-git cl-sophia.asd
cl-spark http://beta.quicklisp.org/archive/cl-spark/2015-07-09/cl-spark-20150709-git.tgz 12519 0eec4e41100c4bbb0ab512e779399604 674f1bc695ae33dc00ab02502078af72720bf098 cl-spark-20150709-git cl-spark-test.asd cl-spark.asd
cl-sparql http://beta.quicklisp.org/archive/cl-sparql/2022-03-31/cl-sparql-20220331-git.tgz 6267 8a8aa37fea1a1dd09368dcb2a1e97596 be35dd462547dc1d2a72a04de9e2a332063dfcc9 cl-sparql-20220331-git cl-sparql-tests.asd cl-sparql.asd
cl-speedy-queue http://beta.quicklisp.org/archive/cl-speedy-queue/2015-03-02/cl-speedy-queue-20150302-git.tgz 3631 509d1acf7e4cfcef99127de75b16521f 476412e42d63703c0b070d23e7e4cbd389d447e9 cl-speedy-queue-20150302-git cl-speedy-queue.asd
cl-sphinx http://beta.quicklisp.org/archive/cl-sphinx/2011-06-19/cl-sphinx-20110619-git.tgz 162782 0aa9e282a8ecc190b788d121071373d6 2ca537aaaac0a4d45151b6a7c8ca71909d10ff5d cl-sphinx-20110619-git sphinx.asd
cl-spidev http://beta.quicklisp.org/archive/cl-spidev/2019-07-10/cl-spidev-20190710-git.tgz 10495 59a6d3341753da1fed9b05864deaabc4 b9338baf09481b93f21f16cea80fc9023b195807 cl-spidev-20190710-git cl-spidev.asd
cl-sqlite http://beta.quicklisp.org/archive/cl-sqlite/2019-08-13/cl-sqlite-20190813-git.tgz 14632 2269773eeb4a101ddd3b33f0f7e05e76 4edb0bfcfc4ec79ab48038c420e415b817c054f8 cl-sqlite-20190813-git sqlite.asd
cl-ssdb http://beta.quicklisp.org/archive/cl-ssdb/2021-01-24/cl-ssdb-20210124-git.tgz 16131 148abb8cb18da310ae4d36a965b47dcd 69666b8d81b1743222096a02264933b04279207d cl-ssdb-20210124-git cl-ssdb-test.asd cl-ssdb.asd
cl-sse http://beta.quicklisp.org/archive/cl-sse/2021-08-07/cl-sse-20210807-git.tgz 8888 ea88f4134f889a68520d94f2b8d248aa 3e44496e270416e68e47d2d04ab35164ded19ff4 cl-sse-20210807-git sse-client-test.asd sse-client.asd sse-demo.asd sse-server-test.asd sse-server.asd
cl-ssh-keys http://beta.quicklisp.org/archive/cl-ssh-keys/2021-05-31/cl-ssh-keys-20210531-git.tgz 3559761 bac9c739707c2ebcf501ae1e8037faba 13408193dedf39d5c67768d1ecb866a423567c53 cl-ssh-keys-20210531-git cl-ssh-keys.asd cl-ssh-keys.test.asd
cl-statsd http://beta.quicklisp.org/archive/cl-statsd/2017-01-24/cl-statsd-20170124-git.tgz 6437 bc58e298a1cf3657375eeb7e9981d993 65edf0606df6f93ff2b212c619c1f315e68a0de1 cl-statsd-20170124-git cl-statsd.asd cl-statsd.test.asd
cl-stdutils http://beta.quicklisp.org/archive/cl-stdutils/2011-10-01/cl-stdutils-20111001-git.tgz 114509 0fa8879ce4004924ff1f534e9fb92dba 4204504d7107cd3eae33550c4e00797fa4dfba98 cl-stdutils-20111001-git stdutils.asd
cl-steamworks http://beta.quicklisp.org/archive/cl-steamworks/2022-11-06/cl-steamworks-20221106-git.tgz 103396 71a73a38f531c2225dc8072f4ca459ab a0b37464dcf09923890c9d5090a3cc4f73db5c0a cl-steamworks-20221106-git cl-steamworks-generator.asd cl-steamworks.asd
cl-stomp http://beta.quicklisp.org/archive/cl-stomp/2020-09-25/cl-stomp-20200925-git.tgz 7757 8f5a1c3ce31e9a08f2481e727b17036a 587b44fddf2756bf038c28b231d77596855fc5ab cl-stomp-20200925-git cl-stomp.asd
cl-stopwatch http://beta.quicklisp.org/archive/cl-stopwatch/2019-03-07/cl-stopwatch-20190307-hg.tgz 3481 f8aca8aac1dcaa3ff818e558dfb8471b 3963d39f4cdba3e518f0d027124d647592e77545 cl-stopwatch-20190307-hg cl-stopwatch.asd
cl-store http://beta.quicklisp.org/archive/cl-store/2020-09-25/cl-store-20200925-git.tgz 47511 828a6f3035c5ef869618f6848c47efd7 56287a99cc9fad823ca8f01b6e29f27d515b2571 cl-store-20200925-git cl-store.asd
cl-str http://beta.quicklisp.org/archive/cl-str/2022-11-06/cl-str-20221106-git.tgz 20184 79fdc13764ed91ddb870686c65a7ffc0 1ad0660cc69dee819fabcf0b5662407a50d448c5 cl-str-20221106-git str.asd str.test.asd
cl-stream http://beta.quicklisp.org/archive/cl-stream/2019-05-21/cl-stream-20190521-git.tgz 10083 99bb43715db14c688bb32be11e4fee8b bd4e03b1155b2a3fe9a9a6faaae493f48bc0ad95 cl-stream-20190521-git cl-stream.asd
cl-strftime http://beta.quicklisp.org/archive/cl-strftime/2016-03-18/cl-strftime-20160318-git.tgz 7797 73097d6d00eca45c52ca5bedc99d0146 27c12e403c68bd330feffadd2b766cb9db160347 cl-strftime-20160318-git cl-strftime.asd
cl-string-complete http://beta.quicklisp.org/archive/cl-string-complete/2019-03-07/cl-string-complete-20190307-hg.tgz 5305 e828ace268105ad02b58ed26498ad28f eab194a8bfb0efe55ac8f0c7d8411e5e16408556 cl-string-complete-20190307-hg cl-string-complete.asd
cl-string-generator http://beta.quicklisp.org/archive/cl-string-generator/2021-06-30/cl-string-generator-20210630-git.tgz 5487 e8c6dc885c33e03ad6e30a07431ba025 e471f55f47cae73f2ff37c977a5fb1fb037dd5c8 cl-string-generator-20210630-git cl-string-generator.asd
cl-string-match http://beta.quicklisp.org/archive/cl-string-match/2021-12-09/cl-string-match-20211209-git.tgz 175821 56a6b7c7e3ff736f0ac2219e8e2777dd 8be6950ddfed2c6aa66bf8c10933efc76a49d15d cl-string-match-20211209-git ascii-strings.asd cl-string-match-test.asd cl-string-match.asd simple-scanf.asd
cl-strings http://beta.quicklisp.org/archive/cl-strings/2021-04-11/cl-strings-20210411-git.tgz 11200 ce6f2c80a8c245f414afd92230729182 bc5b16309a8fe03e95995634d1a5364911e77c3f cl-strings-20210411-git cl-strings.asd
cl-svg http://beta.quicklisp.org/archive/cl-svg/2018-02-28/cl-svg-20180228-git.tgz 83379 672145ecadef2259a3833886dbe68617 1640e08a5ddbcc328a3b4240c13ff91cac3c5454 cl-svg-20180228-git cl-svg.asd
cl-svm http://beta.quicklisp.org/archive/cl-svm/2011-04-18/cl-svm-20110418-git.tgz 435539 c093c5810a77b5258a6b463168c7c8bb 8e4d8ad0cb5ec177c2373b14c251c5932a84615b cl-svm-20110418-git cl-svm.asd
cl-swagger-codegen http://beta.quicklisp.org/archive/cl-swagger-codegen/2018-08-31/cl-swagger-codegen-20180831-git.tgz 43309 5066805afea5280e16e3e58f05cd88e1 9b69504759ff81308c486b266ff3484d2a6e8531 cl-swagger-codegen-20180831-git cl-swagger.asd
cl-sxml http://beta.quicklisp.org/archive/cl-sxml/2020-03-25/cl-sxml-20200325-git.tgz 15164 18c9542922dd4eb00257e194b55e6ed2 230ab25f47940c5802392b968c67dd1fbe50f9bd cl-sxml-20200325-git cl-sxml.asd
cl-syntax http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz 3102 602b84143aafe59d65f4e08ac20a124a e00e7def72875fd635f7e9d27e24fd3f23076247 cl-syntax-20150407-git cl-syntax-annot.asd cl-syntax-anonfun.asd cl-syntax-clsql.asd cl-syntax-fare-quasiquote.asd cl-syntax-interpol.asd cl-syntax-markup.asd cl-syntax.asd
cl-sysexits http://beta.quicklisp.org/archive/cl-sysexits/2022-07-07/cl-sysexits-20220707-git.tgz 2911 e70aa7eab540927281983208de1eb265 725376bb1502e01d1b01165ab7f487315c7fc1a8 cl-sysexits-20220707-git sysexits.asd
cl-syslog http://beta.quicklisp.org/archive/cl-syslog/2019-02-02/cl-syslog-20190202-git.tgz 14759 eafff19eb1f38a36a9535c729d2217fe de0c891d0168db0a3079707794b5fafae6d99282 cl-syslog-20190202-git cl-syslog.asd
cl-table http://beta.quicklisp.org/archive/cl-table/2013-01-28/cl-table-20130128-git.tgz 4002 793e1222aebf00d28d4ec58173bd36b5 93e0aa5fb21ae9722e78814471019d1c2c62f6a3 cl-table-20130128-git cl-table.asd
cl-tar http://beta.quicklisp.org/archive/cl-tar/2022-02-20/cl-tar-20220220-git.tgz 54312 9af1ebb06794ec774f26045b947222a7 5a14debdfaad49db90c1f12f964d6d1499c63d3c cl-tar-20220220-git tar.asd
cl-tar-file http://beta.quicklisp.org/archive/cl-tar-file/2022-02-20/cl-tar-file-20220220-git.tgz 31663 a78c19197708fa923ac7afe517283c11 f925da4c4205a32f9f86b3702b4de5311461b353 cl-tar-file-20220220-git tar-file.asd
cl-tasukete http://beta.quicklisp.org/archive/cl-tasukete/2018-02-28/cl-tasukete-20180228-git.tgz 5602 f4dc086f01e384684b371fbcf631c29b 793c27bce80661019dd5920e02074e538bd22855 cl-tasukete-20180228-git cl-tasukete-test.asd cl-tasukete.asd
cl-tcod http://beta.quicklisp.org/archive/cl-tcod/2020-12-20/cl-tcod-20201220-git.tgz 90205 08603e896222696c4b3ed3be60c7c284 017e418eb198a5f1b8cf69d403b9ac2bd22220e8 cl-tcod-20201220-git parse-rgb.asd tcod.asd
cl-telebot http://beta.quicklisp.org/archive/cl-telebot/2021-10-20/cl-telebot-20211020-git.tgz 5287 9c28d1a26d4bbe5e95609f548c587a72 0b84604463547f219a361217a88c3ec786c73059 cl-telebot-20211020-git cl-telebot.asd
cl-telegram-bot http://beta.quicklisp.org/archive/cl-telegram-bot/2022-11-06/cl-telegram-bot-20221106-git.tgz 434242 22fc926003c0675924b538d673a2e772 782c475849dd8aad678901bdb5256e1fead77466 cl-telegram-bot-20221106-git cl-telegram-bot.asd
cl-template http://beta.quicklisp.org/archive/cl-template/2013-06-15/cl-template-20130615-git.tgz 8316 9ff3872864a04535fa4fdd541e5fef70 3407880226be0be8fd02890e3ef18a2c9c8899f6 cl-template-20130615-git cl-template.asd
cl-termbox http://beta.quicklisp.org/archive/cl-termbox/2021-10-20/cl-termbox-20211020-git.tgz 8149 0045100d8a18e03f50d2548c5b81d7e2 8889182b54468573459c52f99d69fd5ba4136feb cl-termbox-20211020-git cl-termbox.asd
cl-tesseract http://beta.quicklisp.org/archive/cl-tesseract/2017-11-30/cl-tesseract-20171130-git.tgz 8190 761384aa2cde1733a96d6fca82d00750 98cef4ac03acf09549444079e5da579b19ebdc7a cl-tesseract-20171130-git cl-tesseract.asd
cl-tetris3d http://beta.quicklisp.org/archive/cl-tetris3d/2018-12-10/cl-tetris3d-20181210-git.tgz 5744 66d1a4aa18316e25bc0a7df127be71e7 5ea752a06b16d0d4aff9ad6a1bf5acc3eda92faf cl-tetris3d-20181210-git cl-tetris3d.asd
cl-textmagic http://beta.quicklisp.org/archive/cl-textmagic/2015-12-18/cl-textmagic-20151218-git.tgz 2035 f746d2e7ddea99e9cbe443e4a6c08175 3473012d8f21242b2a9bb6a85544938fe2c4a536 cl-textmagic-20151218-git cl-textmagic-test.asd cl-textmagic.asd
cl-tga http://beta.quicklisp.org/archive/cl-tga/2016-03-18/cl-tga-20160318-git.tgz 312452 84bf8ad6fc66ffd2519b933469ae3660 2d2b8b4fd47dde90818f6600bd73bf3cc0ede60f cl-tga-20160318-git cl-tga.asd
cl-threadpool http://beta.quicklisp.org/archive/cl-threadpool/2021-02-28/cl-threadpool-quickload-current-release-86ef8a6b-git.tgz 14319 1c9663c4b2e414968ce826a2a7b72ba1 656f19728a25ee205bcf66f22fd20d9b09e28f7f cl-threadpool-quickload-current-release-86ef8a6b-git cl-threadpool.asd
cl-tidy http://beta.quicklisp.org/archive/cl-tidy/2017-08-30/cl-tidy-20170830-git.tgz 6451 753b926424eaf57415e3cdb2545f4b51 8510d6d70053a5dcf0471a22507013b245695875 cl-tidy-20170830-git cl-tidy.asd
cl-tiled http://beta.quicklisp.org/archive/cl-tiled/2021-05-31/cl-tiled-20210531-git.tgz 18197 3e1584ed300697c9e43093528fb1f374 d5786b7c2e0006a2d34a645d7c2481690874cf3f cl-tiled-20210531-git cl-tiled.asd
cl-tk http://beta.quicklisp.org/archive/cl-tk/2015-06-08/cl-tk-20150608-git.tgz 11254 c6711a6dea114a6c3dec446420eec0f7 a69f6d26b9018482347f83542b91d5f913c13d4c cl-tk-20150608-git cl-tk.asd
cl-tld http://beta.quicklisp.org/archive/cl-tld/2022-02-20/cl-tld-20220220-git.tgz 78855 ce946650750ac973bbaa36389c8a7d8a f29d6220a0479fa229fd485d23766916d76a32d0 cl-tld-20220220-git cl-tld.asd
cl-tls http://beta.quicklisp.org/archive/cl-tls/2022-11-06/cl-tls-20221106-git.tgz 51433 76917357456d3962b1f5973d1aa51e29 e1cf5a8ed49d886e3e68542f084349a0bccf7d28 cl-tls-20221106-git cl-tls.asd
cl-tokyo-cabinet http://beta.quicklisp.org/archive/cl-tokyo-cabinet/2016-08-25/cl-tokyo-cabinet-20160825-git.tgz 19667 00d4bb23e393c6966b4acf17d9184627 9d22fd186290b36752b32010589d8f6b6c31024d cl-tokyo-cabinet-20160825-git cl-tokyo-cabinet-test.asd cl-tokyo-cabinet.asd
cl-toml http://beta.quicklisp.org/archive/cl-toml/2019-11-30/cl-toml-20191130-git.tgz 8835 093bee6524054b0b515d52db070eb300 8cf25c892ca26097b7d4880e49b8d32439ed4095 cl-toml-20191130-git cl-toml-test.asd cl-toml.asd
cl-torrents http://beta.quicklisp.org/archive/cl-torrents/2022-11-06/cl-torrents-20221106-git.tgz 581434 f6e1a792284f8e40f7ab2dc4d62288bf a1ba85db543dd22ad17bf606ffa4d0f6c1caf4fb cl-torrents-20221106-git torrents-test.asd torrents.asd
cl-transmission http://beta.quicklisp.org/archive/cl-transmission/2020-03-25/cl-transmission-20200325-git.tgz 8830 3e01cd078ee2b8b1d703c6f3d031e632 e891aa1e92565bbbf707e51ff0d26112f6dda11a cl-transmission-20200325-git cl-transmission-test.asd cl-transmission.asd
cl-trie http://beta.quicklisp.org/archive/cl-trie/2018-02-28/cl-trie-20180228-git.tgz 11400 20a0f0facbed0ccfad54bfeac6dcbba7 3e5dc74d7aeb063b2cdb3a8a267b946606c1e541 cl-trie-20180228-git cl-trie-examples.asd cl-trie.asd
cl-tui http://beta.quicklisp.org/archive/cl-tui/2020-04-27/cl-tui-20200427-git.tgz 15307 5e1013c1334ce736d2fbfbfa4643ed6e 284a85a4029a3c9697e97f345dd8b402da0b8da3 cl-tui-20200427-git cl-tui.asd
cl-tulip-graph http://beta.quicklisp.org/archive/cl-tulip-graph/2013-06-15/cl-tulip-graph-20130615-git.tgz 14772 eaf9d92e3bffcf93220052fd42b4d002 060726c29d1b14f683149de192541e5b30a99877 cl-tulip-graph-20130615-git cl-tulip-graph.asd
cl-tuples http://beta.quicklisp.org/archive/cl-tuples/2014-07-13/cl-tuples-20140713-git.tgz 28047 8676dd7e0be1af17f5ffa8aac21d0ab3 c977ce6c441bd413c363d63cc99382ff33192dff cl-tuples-20140713-git cl-tuples.asd
cl-twitter http://beta.quicklisp.org/archive/cl-twitter/2018-02-28/cl-twitter-20180228-git.tgz 70934 83638a0508cda507500ef9e633f6cec4 620458f22d28ab5e6f33027c492e7fe1cae28c48 cl-twitter-20180228-git cl-twit-repl.asd cl-twitter.asd twitter-mongodb-driver.asd
cl-typesetting http://beta.quicklisp.org/archive/cl-typesetting/2021-05-31/cl-typesetting-20210531-git.tgz 336818 849e6fb2c4a33f823c005e4e9abb31b5 2a38325b2e4a679ae8741804b1d70495ba112ee8 cl-typesetting-20210531-git cl-typesetting.asd contrib/xhtml-renderer/xml-render.asd documentation/lisp-source/cl-pdf-doc.asd
cl-uglify-js http://beta.quicklisp.org/archive/cl-uglify-js/2015-07-09/cl-uglify-js-20150709-git.tgz 17631 f0ac4a43bb9da2478e995802b86df6dd b806550d06d7844466d36235876ff0a1698e854b cl-uglify-js-20150709-git cl-uglify-js.asd
cl-unicode http://beta.quicklisp.org/archive/cl-unicode/2021-02-28/cl-unicode-20210228-git.tgz 1290638 5b3bdddde3be5b8427e3fac92495a10b 178c37695c1679ca23ec02e48e9942e820640615 cl-unicode-20210228-git cl-unicode.asd
cl-unification http://beta.quicklisp.org/archive/cl-unification/2021-12-30/cl-unification-20211230-git.tgz 33080 7be56c62289bb8db07a8caaea4102ac4 e529c7e8dea171f6179bd430ab46fc25665d5093 cl-unification-20211230-git cl-unification-lib.asd cl-unification-test.asd cl-unification.asd lib-dependent/cl-ppcre-template.asd
cl-union-find http://beta.quicklisp.org/archive/cl-union-find/2022-11-06/cl-union-find-20221106-git.tgz 12700 3f797a6885708feea04c50f07ba12e66 b9faf417d17339a3c87ec251f027297d24fd3185 cl-union-find-20221106-git cl-union-find.asd
cl-unix-sockets http://beta.quicklisp.org/archive/cl-unix-sockets/2022-11-06/cl-unix-sockets-20221106-git.tgz 9083 e475fb2403897b82e8ad188679d51414 4f37be2830bb90ae6a4fff6cb178876148cf9430 cl-unix-sockets-20221106-git unix-sockets.asd unix-sockets.tests.asd
cl-utilities http://beta.quicklisp.org/archive/cl-utilities/2010-10-06/cl-utilities-1.2.4.tgz 22998 c3a4ba38b627448d3ed40ce888048940 187862251617676b95b1386e277fb2c449472bf8 cl-utilities-1.2.4 cl-utilities.asd
cl-utils http://beta.quicklisp.org/archive/cl-utils/2022-11-06/cl-utils-20221106-git.tgz 186568 2dcaa0f8107b4958b5c85c09c143c934 95d22e11bbf6345b0d4350249bab594fb5a3cc37 cl-utils-20221106-git gt.asd
cl-variates http://beta.quicklisp.org/archive/cl-variates/2018-01-31/cl-variates-20180131-darcs.tgz 13536 dd441faa5cf87e4f41102c4a2323f95f 0ee1831ebbfe0c3efb4a5a02936f8a01b624abcc cl-variates-20180131-darcs cl-variates.asd
cl-vectors http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz 31415 9d9629786d4f2c19c15cc6cd3049c343 55f19b15187b1a1026c7fd139fedf3cb7663847b cl-vectors-20180228-git cl-aa-misc.asd cl-aa.asd cl-paths-ttf.asd cl-paths.asd cl-vectors.asd
cl-veq http://beta.quicklisp.org/archive/cl-veq/2022-07-07/cl-veq-20220707-git.tgz 60680 719f98d7d9fd8c30659d5c9418bdebde 9156246d04d8fea906231ed0ef07dbe1e7eef96b cl-veq-20220707-git veq.asd
cl-vhdl http://beta.quicklisp.org/archive/cl-vhdl/2016-04-21/cl-vhdl-20160421-git.tgz 38493 1cae44b3e18d5b1416e9c3afb7382f76 030aa263142eff790f30a947c7b606b7b6021d97 cl-vhdl-20160421-git cl-vhdl.asd
cl-video http://beta.quicklisp.org/archive/cl-video/2018-02-28/cl-video-20180228-git.tgz 9729 1390350148bca3730b1a7d24e298d0e2 82c761ab17ae349f4ec7efff0f438e1dfa57af3d cl-video-20180228-git cl-video-avi.asd cl-video-gif.asd cl-video-player.asd cl-video-wav.asd cl-video.asd
cl-virtualbox http://beta.quicklisp.org/archive/cl-virtualbox/2018-08-31/cl-virtualbox-20180831-git.tgz 5029 f75919b162c344bf5b3bee1bf3f91e32 90de58049f50133366139c8e37e5e8548ff1bce9 cl-virtualbox-20180831-git cl-virtualbox.asd
cl-voipms http://beta.quicklisp.org/archive/cl-voipms/2022-07-07/cl-voipms-20220707-git.tgz 3778 be0b365ec77255ee06fd845ffb634d0e 230e2f6c83eeebea83d8b53677f4c4b5472013e1 cl-voipms-20220707-git voipms.asd
cl-vorbis http://beta.quicklisp.org/archive/cl-vorbis/2022-07-07/cl-vorbis-20220707-git.tgz 461684 f03cdbaacc679eae8311360ce7fb391f 0b0f98994cb9386bb754db219eca7b4971d3ff95 cl-vorbis-20220707-git cl-vorbis.asd
cl-voxelize http://beta.quicklisp.org/archive/cl-voxelize/2015-07-09/cl-voxelize-20150709-git.tgz 118708 2e3d839d201d64659726f553bebd6ac0 104f867098b7cde4f4ccd449633cd9a407e8ce46 cl-voxelize-20150709-git cl-voxelize-examples.asd cl-voxelize-test.asd cl-voxelize.asd
cl-wadler-pprint http://beta.quicklisp.org/archive/cl-wadler-pprint/2019-10-07/cl-wadler-pprint-20191007-git.tgz 4900 030262f0ac47b84a4cfbfa3e423b7eee c68f97c39c540a1bcd35023df432e026b651ded3 cl-wadler-pprint-20191007-git cl-wadler-pprint.asd
cl-wav http://beta.quicklisp.org/archive/cl-wav/2022-11-06/cl-wav-20221106-git.tgz 3406 36f4df412d800e1ca931053d2f70ffbf 012c88a29a53c2830f9834dc801d659d48e5da3e cl-wav-20221106-git cl-wav.asd
cl-wave-file-writer http://beta.quicklisp.org/archive/cl-wave-file-writer/2021-10-20/cl-wave-file-writer-quickload-current-release-42cde6cf-git.tgz 5198 f224924825b7b430394f90e53fa565be 43f5d23724accf16e733bab525bf5856af14f901 cl-wave-file-writer-quickload-current-release-42cde6cf-git cl-wave-file-writer.asd
cl-wavelets http://beta.quicklisp.org/archive/cl-wavelets/2022-07-07/cl-wavelets-20220707-git.tgz 685880 097662392d4de012821a11787d95c686 20bf63988f821916b3cc305a37616187e213c2d4 cl-wavelets-20220707-git cl-wavelets.asd
cl-wayland http://beta.quicklisp.org/archive/cl-wayland/2019-03-07/cl-wayland-20190307-git.tgz 44560 31887db1bf34dcf36f3978c8004d4e0f 9a189cafa43b0da7d79a9421afa30bebbf7db6ec cl-wayland-20190307-git cl-wayland.asd
cl-weather-jp http://beta.quicklisp.org/archive/cl-weather-jp/2016-02-08/cl-weather-jp-20160208-git.tgz 3398 705667b6c865f440d1667ccc5f83a8fb 3c40d7f65d92a9485ec4bb8e89c0d0af8d5e73c3 cl-weather-jp-20160208-git cl-weather-jp-test.asd cl-weather-jp.asd
cl-webdav http://beta.quicklisp.org/archive/cl-webdav/2017-08-30/cl-webdav-20170830-git.tgz 77311 9b5b1bbe0b24734a652a464f6924a019 68cbdcabb6c6e8c61ff4757554efa3e83af3e2a1 cl-webdav-20170830-git cl-webdav.asd
cl-webdriver-client http://beta.quicklisp.org/archive/cl-webdriver-client/2021-12-30/cl-webdriver-client-20211230-git.tgz 304955 40bdc00810a476dfe52863130e0b792a 4b44e3b40ff1e920a8802934eaecbf35c19e8cc0 cl-webdriver-client-20211230-git cl-webdriver-client-test.asd cl-webdriver-client.asd
cl-webkit http://beta.quicklisp.org/archive/cl-webkit/2022-11-06/cl-webkit-20221106-git.tgz 39184 514dc944ae8a4b39fa4f89c98776817b 4b730919e5d4342caa0578993b40140852454ce8 cl-webkit-20221106-git webkit2/cl-webkit2.asd
cl-who http://beta.quicklisp.org/archive/cl-who/2022-03-31/cl-who-20220331-git.tgz 24823 109e7be9ab5c1680f18ddd26095a60f6 89bced0ab2a84088dda0727a71df386786715315 cl-who-20220331-git cl-who.asd
cl-why http://beta.quicklisp.org/archive/cl-why/2018-02-28/cl-why-20180228-git.tgz 25872 00a337f35a516372da41415d25fb879b 86790d0b92642b89a6fde16249597db175cfb407 cl-why-20180228-git cl-why.asd
cl-with http://beta.quicklisp.org/archive/cl-with/2021-10-20/cl-with-20211020-git.tgz 8888 6f847fc44734f48d5dde0b6326afc7f8 f90c2098ab3828d1472a7d1c7a2a2831d50ffb32 cl-with-20211020-git cl-with.asd
cl-wol http://beta.quicklisp.org/archive/cl-wol/2022-03-31/cl-wol-20220331-git.tgz 547681 2314a9232065473fc6055a4d0d361008 9c982eebae02b60ad342b033176f7b0a55b51af8 cl-wol-20220331-git cl-wol.cli.asd cl-wol.core.asd cl-wol.test.asd
cl-wordcut http://beta.quicklisp.org/archive/cl-wordcut/2016-04-21/cl-wordcut-20160421-git.tgz 301706 1f251cf2df7f1946887d09c82e3ce968 4b7bbb407529d93d44f9799646a19301c9a81826 cl-wordcut-20160421-git cl-wordcut.asd
cl-xdg http://beta.quicklisp.org/archive/cl-xdg/2017-01-24/cl-xdg-20170124-git.tgz 22666 eaf304bd5c23c58f45f161afe180c2d4 dbdcbe7542181ebf9bfde5c57f120543a937911a cl-xdg-20170124-git cl-xdg.asd
cl-xkb http://beta.quicklisp.org/archive/cl-xkb/2022-11-06/cl-xkb-20221106-git.tgz 5364 2021bcb280ca5f4a160f779eaf2a99a4 ddf7290ffe06633e1911649180985f45a18cdf62 cl-xkb-20221106-git cl-xkb.asd
cl-xkeysym http://beta.quicklisp.org/archive/cl-xkeysym/2014-09-14/cl-xkeysym-20140914-git.tgz 38246 15ad40d06aa25589bdb59ac5ef485b8c 3d95e7111d9560e75772dbdbd6655b917ede6d47 cl-xkeysym-20140914-git cl-xkeysym.asd
cl-xmlspam http://beta.quicklisp.org/archive/cl-xmlspam/2010-10-06/cl-xmlspam-20101006-http.tgz 10705 6e3a0944e96e17916b1445f4207babb8 82b47ae3227d537486d6bea267c473a068729ecd cl-xmlspam-20101006-http cl-xmlspam.asd
cl-xmpp http://beta.quicklisp.org/archive/cl-xmpp/2010-10-06/cl-xmpp-0.8.1.tgz 15271 303b035edd3bde5aa85c423278298e88 23935110f714202ce650c7e31af12fbbc1f22130 cl-xmpp-0.8.1 cl-xmpp-sasl.asd cl-xmpp-tls.asd cl-xmpp.asd
cl-xul http://beta.quicklisp.org/archive/cl-xul/2016-03-18/cl-xul-20160318-git.tgz 518863 2fbb767b222e632df40a3b7a57aa7f3e 19ad37e6129833ed96d57f92246922462d8f9fb9 cl-xul-20160318-git cl-xul-test.asd cl-xul.asd
cl-yacc http://beta.quicklisp.org/archive/cl-yacc/2010-10-06/cl-yacc-20101006-darcs.tgz 18774 748b9d59de8be3ccfdf0f001e15972ba 7e224cde172cc9db229385fcef1ee411403f9ff6 cl-yacc-20101006-darcs yacc.asd
cl-yaclyaml http://beta.quicklisp.org/archive/cl-yaclyaml/2016-08-25/cl-yaclyaml-20160825-git.tgz 35546 73ddfe97a2b8214e319b366245a216c2 fd3ddd09d55fb1176db7b23f16e3874d6c5018a6 cl-yaclyaml-20160825-git cl-yaclyaml.asd
cl-yahoo-finance http://beta.quicklisp.org/archive/cl-yahoo-finance/2013-03-12/cl-yahoo-finance-20130312-git.tgz 7759 ef1129e9f2bd7afbdde50048db25cc94 9801bb213a303af511c38d63a126b718a2b65085 cl-yahoo-finance-20130312-git cl-yahoo-finance.asd
cl-yaml http://beta.quicklisp.org/archive/cl-yaml/2022-11-06/cl-yaml-20221106-git.tgz 14123 3d24075506f8f8ffcc627f3800d95063 5aff81c9d2f79479273599e7c9c43deca082b9ec cl-yaml-20221106-git cl-yaml-test.asd cl-yaml.asd
cl-yesql http://beta.quicklisp.org/archive/cl-yesql/2021-10-20/cl-yesql-20211020-git.tgz 13469 77b1b8c4408dae5f726215cd24087e87 5d277fd9d2d00ccabf8d557b6528ca888758feee cl-yesql-20211020-git cl-yesql.asd
cl-yxorp http://beta.quicklisp.org/archive/cl-yxorp/2022-11-06/cl-yxorp-20221106-git.tgz 18499 a0a0e2b1fa057ec4a491e388299790ed f321012d84fe4fc49b60aaecead052126337e2b3 cl-yxorp-20221106-git yxorp.asd
cl-zipper http://beta.quicklisp.org/archive/cl-zipper/2020-06-10/cl-zipper-20200610-git.tgz 4193 69142f465d6d2d949699884dd2449843 b4f9c78e07dd1362ef459a4109fc0dbc6d38213a cl-zipper-20200610-git cl-zipper.asd
cl-zmq http://beta.quicklisp.org/archive/cl-zmq/2016-03-18/cl-zmq-20160318-git.tgz 13519 2edc111c3fa50504eb2ef997f9ded9c4 b50410e4f435a9e85b3d91df8101fb2048594ab0 cl-zmq-20160318-git zeromq.asd
cl-zstd http://beta.quicklisp.org/archive/cl-zstd/2022-11-06/cl-zstd-20221106-git.tgz 576657 bd3e6e31a5dbc89e89603b2afeb68047 0ccf80c739a8b388fab0ef8b5e7c6f978b131ee5 cl-zstd-20221106-git zstd-tests.asd zstd.asd
cl-zyre http://beta.quicklisp.org/archive/cl-zyre/2020-09-25/cl-zyre-20200925-git.tgz 14876 3f92fc184b0aea074a3a6bbd2e09b2d7 357f02010f6d3293263adf3f062dc96fe6cd476d cl-zyre-20200925-git zyre.asd
cl4store http://beta.quicklisp.org/archive/cl4store/2020-03-25/cl4store-20200325-git.tgz 7080 bb3a80be4cb130697cb10704a0b9dc80 a3de4511da49e9fb60e41d9c4f029974e3c06ce6 cl4store-20200325-git cl4store.asd
clache http://beta.quicklisp.org/archive/clache/2017-11-30/clache-20171130-git.tgz 5875 e319e26205af015787e5cd893eeb58cd 2c09d8401c5e225019bb7393ca899e0056f31790 clache-20171130-git clache-test.asd clache.asd
clack http://beta.quicklisp.org/archive/clack/2022-11-06/clack-20221106-git.tgz 172573 16c983f1974cf364e14d20fbc637ca5f b35b6b4cd244c8ba405fd27b09385609ef48945a clack-20221106-git clack-handler-fcgi.asd clack-handler-hunchentoot.asd clack-handler-toot.asd clack-handler-wookie.asd clack-socket.asd clack-test.asd clack.asd t-clack-handler-fcgi.asd t-clack-handler-hunchentoot.asd t-clack-handler-toot.asd t-clack-handler-wookie.asd
clack-errors http://beta.quicklisp.org/archive/clack-errors/2019-08-13/clack-errors-20190813-git.tgz 278838 bbae5cf71b4d95e5dbb51c1b8cc11ff0 35df80382645afdbc51214118d2542bd446e3e6a clack-errors-20190813-git clack-errors-demo.asd clack-errors-test.asd clack-errors.asd lack-middleware-clack-errors.asd
clack-pretend http://beta.quicklisp.org/archive/clack-pretend/2021-06-30/clack-pretend-20210630-git.tgz 7042 98a342fbb3cb42dd26cf297ec55e5eca 733fb06c3eb21796672978478e93138fa2675e29 clack-pretend-20210630-git clack-pretend.asd
clack-static-asset-middleware http://beta.quicklisp.org/archive/clack-static-asset-middleware/2021-12-09/clack-static-asset-middleware-20211209-git.tgz 22522 6e6559ff6390e551d41b9919c0ce7c4a fd16372601f4a7a460dc7e631acdcf90f4b9ddd4 clack-static-asset-middleware-20211209-git clack-static-asset-djula-helpers.asd clack-static-asset-middleware-test.asd clack-static-asset-middleware.asd
clad http://beta.quicklisp.org/archive/clad/2021-12-30/clad-20211230-git.tgz 11749 628290571a50af5c362180173efac8b3 ec3e9316fabed4e5a894e3685a628960239aef04 clad-20211230-git clad.asd
class-options http://beta.quicklisp.org/archive/class-options/2020-10-16/class-options_1.0.1.tgz 6926 6a11f6d5e892755f2e1bbac090d9ead0 774b7e9a97649a231da89bd4c2a6335dcc018adb class-options_1.0.1 class-options.asd tests/class-options_tests.asd
classimp http://beta.quicklisp.org/archive/classimp/2020-03-25/classimp-20200325-git.tgz 35560 56551bf063f1a1fcf6c9be351ec9609e ad53d09ba54dd7af8be8548816265f96b43f013d classimp-20200325-git classimp-samples.asd classimp.asd
classowary http://beta.quicklisp.org/archive/classowary/2019-10-07/classowary-20191007-git.tgz 24900 a2587986780a40251b0327686b817cc6 cce68e75254543ae11458499c408544f67dda874 classowary-20191007-git classowary-test.asd classowary.asd
clast http://beta.quicklisp.org/archive/clast/2021-12-30/clast-20211230-git.tgz 56449 e0e6677a7c20801d82519f15f4dafb72 97368435f912dfdf8f8f60d73d9495ea29dc9009 clast-20211230-git clast.asd
clath http://beta.quicklisp.org/archive/clath/2021-05-31/clath-20210531-git.tgz 14207 f0902d90980482db4d72b145b650e51a 9db5fa0d9cd31d3741db0bae7f07b20cc0dc2089 clath-20210531-git clath.asd
clavatar http://beta.quicklisp.org/archive/clavatar/2012-10-13/clavatar-20121013-git.tgz 3375 2861593e34c92b4faa7edb77be6044bb caf33a796f42b398be84fb304753622550cd41f1 clavatar-20121013-git clavatar.asd
clavier http://beta.quicklisp.org/archive/clavier/2021-05-31/clavier-20210531-git.tgz 7137 f58e50525086be4db8cd28f9beb917f4 9ee60bda35b3332e03cd20302fcd7e8e856c2653 clavier-20210531-git clavier.asd clavier.test.asd
claw http://beta.quicklisp.org/archive/claw/2020-10-16/claw-stable-git.tgz 32500 cbb451472355ace1f0a5da720075e68f 77af6d65748418ca4cf0548bee926d58e5b8c62f claw-stable-git claw.asd
claw-olm http://beta.quicklisp.org/archive/claw-olm/2021-05-31/claw-olm-20210531-git.tgz 544512 a74d3c601f08d60d974587a8f28ec1ea d50b09adbbf50d91790797435d4b73b1d2a3995a claw-olm-20210531-git claw-olm-bindings.asd claw-olm.asd
claw-support http://beta.quicklisp.org/archive/claw-support/2020-10-16/claw-support-stable-git.tgz 1324 e7985725534a250acfa8ebebc9074ba5 d68ba98fca32cd626abbb5337de70a4a6004f199 claw-support-stable-git claw-support.asd
claw-utils http://beta.quicklisp.org/archive/claw-utils/2020-10-16/claw-utils-stable-git.tgz 2216 747e03cc466a4dca2635fa67531dd22d 8952fdc7a383ef498bd223c4a1020fc7a5de951c claw-utils-stable-git claw-utils.asd
clawk http://beta.quicklisp.org/archive/clawk/2020-09-25/clawk-20200925-git.tgz 13899 bea0a80473ce5ca78127a413f43dc8a5 6e4de57cf4c147884d6364b7dff5b94d4d2635d2 clawk-20200925-git clawk.asd
claxy http://beta.quicklisp.org/archive/claxy/2022-02-20/claxy-20220220-git.tgz 5578 eb99a344ea6fa2f5340167617c24752d 041aaac96d123f771f948dae90940563d0fdd1a1 claxy-20220220-git claxy.asd
clazy http://beta.quicklisp.org/archive/clazy/2021-12-30/clazy-20211230-git.tgz 23919 c91e8e03db00c22b8d3e0d47e15de106 213fa045ff648a3f721220f05df987dda2cb1959 clazy-20211230-git clazy.asd
clem http://beta.quicklisp.org/archive/clem/2021-08-07/clem-20210807-git.tgz 84583 c7da8661594bdbeb80a017b4c56abc27 33ee838245718f55abfd2e4ca0d2f21a2108f63e clem-20210807-git clem-benchmark.asd clem-test.asd clem.asd
cleric http://beta.quicklisp.org/archive/cleric/2022-02-20/cleric-20220220-git.tgz 19734 1996565acc23a938a150c7edd38617aa 1226afbf0cd42110008438f9f283d3c52b2bfc46 cleric-20220220-git cleric-test.asd cleric.asd
clerk http://beta.quicklisp.org/archive/clerk/2022-02-20/clerk-20220220-git.tgz 5215 60321d2d1873f8a68c3f462e4c9b6a2e 93a8276ccdae50b7d500a1a2d5f8e7a5674530a9 clerk-20220220-git clerk.asd
clesh http://beta.quicklisp.org/archive/clesh/2020-12-20/clesh-20201220-git.tgz 8029 c9060b2d87d468ed51e0bfd232a62acb 98e901f1b3c3464b81affeca3d5860cd1584ee3f clesh-20201220-git clesh-tests.asd clesh.asd
cletris http://beta.quicklisp.org/archive/cletris/2021-10-20/cletris-20211020-git.tgz 191265 2afe9bdeed653df58bb19e79bdfaeda2 13eecfa04cc507fdf1eb840a1bb1a8f0b51f61be cletris-20211020-git cletris-network.asd cletris-test.asd cletris.asd
clfswm http://beta.quicklisp.org/archive/clfswm/2016-12-04/clfswm-20161204-git.tgz 282721 dc976785ef899837ab0fc50a4ed6b740 f745e9682f549b4d92d31e3e7fcec68d561af370 clfswm-20161204-git clfswm.asd
clgplot http://beta.quicklisp.org/archive/clgplot/2022-11-06/clgplot-20221106-git.tgz 103195 356b851073c3250c6a6f4224f79f0bf7 fa80e1e0d9c81cbde82bebdc8b03a00819d6fedc clgplot-20221106-git clgplot-test.asd clgplot.asd
clhs http://beta.quicklisp.org/archive/clhs/2015-04-07/clhs-0.6.3.tgz 2238743 37b804be8696e555a74f240ebc17bbc6 f1c4c385996573194e15316c2f4167f6d3998859 clhs-0.6.3 clhs.asd
clickr http://beta.quicklisp.org/archive/clickr/2014-07-13/clickr-20140713-git.tgz 23238 264cae768921c6e264d909bb4c40e873 af914f21f5a5cac958bfd57128000580dab268e5 clickr-20140713-git clickr.asd
clim-widgets http://beta.quicklisp.org/archive/clim-widgets/2020-07-15/clim-widgets-20200715-git.tgz 14684 91edd0cf2cc9d7ced786e7e470082d9d 41bbaa57d7f90c9656a5d0cd60f1ce2f2e78d608 clim-widgets-20200715-git clim-widgets.asd
climacs http://beta.quicklisp.org/archive/climacs/2020-09-25/climacs-20200925-git.tgz 112429 37ba98906968c291fb70347ec98ab950 7d75e1385a9eadae7dac2b0dce9ea9f806c23d80 climacs-20200925-git climacs.asd
climc http://beta.quicklisp.org/archive/climc/2022-11-06/climc-20221106-git.tgz 213589 4d9ba5241eaca2ec5d5926e5c352419e 18636b44ebb2c6c38a29174ffab8229e0d787fe7 climc-20221106-git climc-test.asd climc.asd
climon http://beta.quicklisp.org/archive/climon/2022-02-20/climon-20220220-git.tgz 1005430 965ac514545986a550448657354d2a98 1080d4f0ee46bf44eb2bbb48c2f615ceaec0e3b0 climon-20220220-git climon-test.asd climon.asd
clinch http://beta.quicklisp.org/archive/clinch/2018-02-28/clinch-20180228-git.tgz 15291213 26477d753d550ae020ae95c60315d8b3 232f53345667193c6f4899ab6322d31066e31eef clinch-20180228-git clinch-cairo.asd clinch-classimp.asd clinch-freeimage.asd clinch-pango.asd clinch.asd
clinenoise http://beta.quicklisp.org/archive/clinenoise/2020-04-27/clinenoise-20200427-git.tgz 5585 026cb7956427be3a2162254efc33ef84 c0980cd123589fdbcfeabf4d6c8f3e621c431042 clinenoise-20200427-git clinenoise.asd
clingon http://beta.quicklisp.org/archive/clingon/2022-11-06/clingon-20221106-git.tgz 573684 1ddeb782596dd40a287eda6b25aeb5dd e294317c4665c8de2bbf3cdb3f453c37b7078eb0 clingon-20221106-git clingon.asd clingon.demo.asd clingon.intro.asd clingon.test.asd
clip http://beta.quicklisp.org/archive/clip/2021-12-09/clip-20211209-git.tgz 23302 1a5ec4ff75e123888327a5577237002b b3d70466a25850b0de9f020c68a3595cd7426587 clip-20211209-git clip.asd
clipper http://beta.quicklisp.org/archive/clipper/2015-09-23/clipper-20150923-git.tgz 30698 a8d3f3fa89f2d31dd864a55a93604973 d45c4f34e7ea6db2ad08811d2f2b104dd9e5afbc clipper-20150923-git clipper-test.asd clipper.asd
clite http://beta.quicklisp.org/archive/clite/2013-06-15/clite-20130615-git.tgz 4207 e9ec17416118a4bc561b7ac0b1c8fe55 a33f68199901025b79110bb113ac204b47008231 clite-20130615-git clite.asd
clj http://beta.quicklisp.org/archive/clj/2020-12-20/clj-20201220-git.tgz 7182 3df8450abb46784a191b4ab5f9ab4cc9 f6ad8174a9020a000e5eab76fccd1c69633c616d clj-20201220-git clj.asd
clj-con http://beta.quicklisp.org/archive/clj-con/2021-08-07/clj-con-20210807-git.tgz 34193 d9b150e6a23b513e4be5927bbbd33c29 33dee7c801248234a4c4ca93876f2b461242fa27 clj-con-20210807-git clj-con-test.asd clj-con.asd
clj-re http://beta.quicklisp.org/archive/clj-re/2022-11-06/clj-re-20221106-git.tgz 12178 0fd1b83dc4f2f418485cf1c5e3b07eeb 4cb6533a4d9781eadea502dae47c72c76e447931 clj-re-20221106-git clj-re-test.asd clj-re.asd
clml http://beta.quicklisp.org/archive/clml/2022-02-20/clml-20220220-git.tgz 1028980 cc33f459e918d6936764b5c5824ff05d 40445627b742e630749871cb088590e847b3d221 clml-20220220-git addons/fork-future/fork-future.asd addons/future/future.asd association-rule/clml.association-rule.asd blas/clml.blas.asd blas/f2cl-lib.asd classifiers/clml.classifiers.asd clml.asd clustering/clml.clustering.asd data/clml.data.asd data/r-datasets/clml.data.r-datasets.asd decision-tree/clml.decision-tree.asd docs/clml.docs.asd graph/clml.graph.asd hjs/clml.hjs.asd lapack/clml.lapack.asd nearest-search/clml.nearest-search.asd nonparametric/clml.nonparametric.asd numeric/clml.numeric.asd pca/clml.pca.asd som/clml.som.asd statistics/clml.statistics.asd statistics/clml.statistics.rand.asd svm/clml.svm.asd test/clml.test.asd text/clml.text.asd time-series/clml.time-series.asd utility/clml.utility.asd
clnuplot http://beta.quicklisp.org/archive/clnuplot/2013-01-28/clnuplot-20130128-darcs.tgz 31274 0e5dccbbbe3408b3e0aebf639691c6a0 6a2749d3b7ef6bd1325b92160bb9eee35f099c96 clnuplot-20130128-darcs clnuplot.asd
clobber http://beta.quicklisp.org/archive/clobber/2022-11-06/clobber-20221106-git.tgz 7328 fadcd13a71e021faec1e370950802152 e6f153b9ca5ca72538451ed78d792a3db3509ab1 clobber-20221106-git clobber.asd
clod http://beta.quicklisp.org/archive/clod/2019-03-07/clod-20190307-hg.tgz 98259 df582b015aa80397402eee3bb5a13288 c3bc36581145c5abc6126b2c3ba88386f6ba7876 clod-20190307-hg clod.asd
clods-export http://beta.quicklisp.org/archive/clods-export/2021-04-11/clods-export-20210411-git.tgz 20257 04128d9dcd96f53fb5436025f1bba92f 63776b859dc3ca9b48f8faaeb1e44ebd0e802c3e clods-export-20210411-git clods-export.asd
clog http://beta.quicklisp.org/archive/clog/2022-11-06/clog-20221106-git.tgz 6499681 c2e8e7b1e579a38752fab5a53de3a320 aac6adae2cebff605d0580cebb59817838366faf clog-20221106-git clog.asd tutorial/13-tutorial/hello-clog/hello-clog.asd tutorial/28-tutorial/hello-builder/hello-builder.asd
clog-ace http://beta.quicklisp.org/archive/clog-ace/2022-11-06/clog-ace-20221106-git.tgz 2938359 c3c9e9fb57dcdbcecde6608f3a79a73e 7b9ea6ff8558d54a2619192d93daec6c1cc7037f clog-ace-20221106-git clog-ace.asd
clog-plotly http://beta.quicklisp.org/archive/clog-plotly/2022-11-06/clog-plotly-20221106-git.tgz 221440 c4f7823f2e77de9030f09dd6adaa30a1 eedefa2026da17ddb81279b210c34acc09c5996c clog-plotly-20221106-git clog-plotly.asd
clog-terminal http://beta.quicklisp.org/archive/clog-terminal/2022-11-06/clog-terminal-20221106-git.tgz 420434 f4fbba864bc1323eaeed8820896f4d69 e61258f8b7dc2810eda02003a2deb2b6d8bd8786 clog-terminal-20221106-git clog-terminal.asd
clonsigna http://beta.quicklisp.org/archive/clonsigna/2012-09-09/clonsigna-20120909-git.tgz 42948 3ae74680c33dfd5880914dac3873357c 11bf0a3df0e3309a054015629c01a282148208e5 clonsigna-20120909-git clonsigna.asd
clop http://beta.quicklisp.org/archive/clop/2022-02-20/clop-v1.0.1.tgz 10995 4ad9df2316648497ef94a0a5e122ec57 a6821b0a6338ffd382ed3cc0ca6ab1aced63d7f7 clop-v1.0.1 clop.asd
clos-diff http://beta.quicklisp.org/archive/clos-diff/2015-06-08/clos-diff-20150608-git.tgz 14486 88dbce5dc199deb2ee44e7cb73946db0 8825ffc50639addefd79f604addcacf17309f512 clos-diff-20150608-git clos-diff.asd
clos-fixtures http://beta.quicklisp.org/archive/clos-fixtures/2016-08-25/clos-fixtures-20160825-git.tgz 2687 68898ca907a135d733ecdadb3f8b5723 75e8f147882b9e7fb56519a8c8a91d00798b1df7 clos-fixtures-20160825-git clos-fixtures-test.asd clos-fixtures.asd
closer-mop http://beta.quicklisp.org/archive/closer-mop/2022-11-06/closer-mop-20221106-git.tgz 23769 566e0e0bba1456683087702c62e36af5 5c18ab061e3e26ac2eb1aa8fd3849a00e28bb74b closer-mop-20221106-git closer-mop.asd
closure-common http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz 27833 b09ee60c258a29f0c107960ec4c04ada 42e2f882070d49d3224c15a304354afb29f97841 closure-common-20181018-git closure-common.asd
closure-html http://beta.quicklisp.org/archive/closure-html/2018-07-11/closure-html-20180711-git.tgz 103413 461dc8caa65385da5f2d1cd8dd4f965f d8e52dc5d129aec699cd405c14a9080d01199506 closure-html-20180711-git closure-html.asd
clouchdb http://beta.quicklisp.org/archive/clouchdb/2012-04-07/clouchdb_0.0.16.tgz 33759 d39f8e71a5e1954b40af4291f0c05757 7d254f6edf1a28300e4c4c3fa387b4cfcdf24b28 clouchdb_0.0.16 clouchdb-examples.asd clouchdb.asd
clsql http://beta.quicklisp.org/archive/clsql/2022-11-06/clsql-20221106-git.tgz 968899 5f083505579eb7dfeed90882ebf7dc71 db16fc192662b613d9b63c312dae6f3ae1e9bc5d clsql-20221106-git clsql-aodbc.asd clsql-cffi.asd clsql-mysql.asd clsql-odbc.asd clsql-postgresql-socket.asd clsql-postgresql-socket3.asd clsql-postgresql.asd clsql-sqlite.asd clsql-sqlite3.asd clsql-tests.asd clsql-uffi.asd clsql.asd
clsql-fluid http://beta.quicklisp.org/archive/clsql-fluid/2017-08-30/clsql-fluid-20170830-git.tgz 4361 cd6191a16e81af2670f3ed84b29995b8 af7e03aca8277efe730c86075f3587be71a357c1 clsql-fluid-20170830-git clsql-fluid.asd
clsql-helper http://beta.quicklisp.org/archive/clsql-helper/2018-01-31/clsql-helper-20180131-git.tgz 31200 e3040bc42b24c8b0845abcd4a74d3db4 b92225c63d358fac585ce63bc132cca4bac1f50c clsql-helper-20180131-git clsql-helper-slot-coercer.asd clsql-helper.asd
clsql-local-time http://beta.quicklisp.org/archive/clsql-local-time/2020-10-16/clsql-local-time-20201016-git.tgz 1701 ca6740fcc92f763f43b5a10c22539bfe 5dd91bdf72f41cada66e890bc661ad1355d03de2 clsql-local-time-20201016-git clsql-local-time.asd
clsql-orm http://beta.quicklisp.org/archive/clsql-orm/2016-02-08/clsql-orm-20160208-git.tgz 19760 40b31c2bfbf7b27f35b362fc4cffb6bf 4d07a98d77328076b0844f4708c56087f5618426 clsql-orm-20160208-git clsql-orm.asd
clss http://beta.quicklisp.org/archive/clss/2022-11-06/clss-20221106-git.tgz 21477 3e9422b70401f6029d42027a94938761 e34fedeadd0a700c64126fde8e00a659387b5bc1 clss-20221106-git clss.asd
cltcl http://beta.quicklisp.org/archive/cltcl/2016-12-04/cltcl-20161204-git.tgz 338065 bb57496aeea233c7adb04e3bb6eca551 8d9140fafe4658324f8b354159cdef6d8c9d174b cltcl-20161204-git cltcl.asd
cluffer http://beta.quicklisp.org/archive/cluffer/2022-11-06/cluffer-20221106-git.tgz 102456 714b91946793aa781bc2324b055ec619 39aeaeff76cae7445eeb311be3b0587c2beb4612 cluffer-20221106-git Base/cluffer-base.asd Simple-buffer/cluffer-simple-buffer.asd Simple-line/cluffer-simple-line.asd Standard-buffer/cluffer-standard-buffer.asd Standard-line/cluffer-standard-line.asd Test/cluffer-test.asd cluffer.asd
clump http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz 25593 5132d2800138d435ef69f7e68b025c8f 68760a1e2e6e28ecf8f45e5b766774bc3a18e369 clump-20160825-git 2-3-tree/clump-2-3-tree.asd Binary-tree/clump-binary-tree.asd Test/clump-test.asd clump.asd
clunit http://beta.quicklisp.org/archive/clunit/2017-10-19/clunit-20171019-git.tgz 76811 389017f2f05a6287078ddacd0471817e 26340b858b8c784b90cda75ab57470410507d191 clunit-20171019-git clunit.asd
clunit2 http://beta.quicklisp.org/archive/clunit2/2022-11-06/clunit2-20221106-git.tgz 40384 2b8f33ac4d485e2e9ade3651a643cd7b 09223b2c052891d8dd2a22140cc68090309fae1f clunit2-20221106-git clunit2.asd
cluster http://beta.quicklisp.org/archive/cluster/2022-07-07/cluster-20220707-git.tgz 10087 90f89050ce8696fbc915b7966d2c1d56 37eed27edddb4e293df33986b10d2b96930f03f3 cluster-20220707-git src/clam.asd
clustered-intset http://beta.quicklisp.org/archive/clustered-intset/2022-07-07/clustered-intset-20220707-git.tgz 21705 d852dc8d04d7948e78154cf3c987bdc4 8e9db3a7da64ec6964fbd563add3aa2f05eb23f4 clustered-intset-20220707-git clustered-intset-test.asd clustered-intset.asd
clusters http://beta.quicklisp.org/archive/clusters/2022-03-31/clusters-20220331-git.tgz 20939 fe3df098117f0fbfe339edafd4e782ce bdffe907e7eb0a8fce7941d328b3ea323b63ce51 clusters-20220331-git clusters-tests.asd clusters.asd
clutter http://beta.quicklisp.org/archive/clutter/2021-10-20/clutter-v1.0.0.tgz 12575 9c97f6f5415be3f4c8d948af6dce7818 970f82da357a6009b7a181a79c589a986f4b3635 clutter-v1.0.0 clutter.asd
clweb http://beta.quicklisp.org/archive/clweb/2020-12-20/clweb-20201220-git.tgz 141039 757653ad57dd52eaacc619f4992d5f3f 42bb418e8d07ed10be040b30bb0a7fb491196d8b clweb-20201220-git clweb.asd
clws http://beta.quicklisp.org/archive/clws/2013-08-13/clws-20130813-git.tgz 32371 11a801aadeda244b749c2b36a19b9af9 521463b0aef355a1307f911327fee5ed5d65854d clws-20130813-git clws.asd
clx http://beta.quicklisp.org/archive/clx/2022-11-06/clx-20221106-git.tgz 459307 a018c3707fe077403327aa87120b6b1c 1a30920e9c0354eb1820132ee3db32183f1ae42d clx-20221106-git clx.asd
clx-xembed http://beta.quicklisp.org/archive/clx-xembed/2019-11-30/clx-xembed-20191130-git.tgz 21169 11d35eeb734c0694005a5e5cec4cad22 27ec06dc8e843deb1fd1b01058e78627e5dbf424 clx-xembed-20191130-git xembed.asd
clx-xkeyboard http://beta.quicklisp.org/archive/clx-xkeyboard/2012-08-11/clx-xkeyboard-20120811-git.tgz 47002 4e382b34e05d33f5de8e9c9dea33131c f18ddbbf8f7e5222cb44e2543386a8efd49abb7c clx-xkeyboard-20120811-git xkeyboard.asd
cmake-parser http://beta.quicklisp.org/archive/cmake-parser/2018-08-31/cmake-parser-20180831-git.tgz 5470 901e49335a490ad419aec7bcd4493d47 adc648f94bfc8e9e0834075e88f4098dafd9e982 cmake-parser-20180831-git cmake-parser.asd
cmd http://beta.quicklisp.org/archive/cmd/2022-11-06/cmd-20221106-git.tgz 17842 b63a1b9c99d8bf123f6098a560cc893b 75a1ae56569df37da410334c955881a8ec7cc73b cmd-20221106-git cmd.asd
cmu-infix http://beta.quicklisp.org/archive/cmu-infix/2018-02-28/cmu-infix-20180228-git.tgz 22615 6baab7e8fdbb211c1b1622073b9521c9 408f16c7594f02f53e39ea8b7684721d12406435 cmu-infix-20180228-git cmu-infix-tests.asd cmu-infix.asd
codata-recommended-values http://beta.quicklisp.org/archive/codata-recommended-values/2020-02-18/codata-recommended-values-20200218-git.tgz 364817 d8f489d65671735ec30f0353461f74d1 a6285062e4811d70a0aa3a8322c7b1888b27b538 codata-recommended-values-20200218-git codata-recommended-values.asd
codex http://beta.quicklisp.org/archive/codex/2018-12-10/codex-20181210-git.tgz 185947 7c33d0361d2e50d968aade71461443f4 7d7ee6fbc90ecdaa755d4f2f1b986d24d03ff912 codex-20181210-git codex-templates.asd codex.asd
coleslaw http://beta.quicklisp.org/archive/coleslaw/2022-11-06/coleslaw-20221106-git.tgz 167408 0703e51091e6c932d0c31e0556ea48e5 603fcb3dd7452503bb46d27b1c77910114871301 coleslaw-20221106-git coleslaw-cli.asd coleslaw-test.asd coleslaw.asd
collectors http://beta.quicklisp.org/archive/collectors/2022-02-20/collectors-20220220-git.tgz 10410 429ba50dd0a45e5a6e093a13b2d23d0e 76a01575c0ceebf5f091482aee6dd9604801c97c collectors-20220220-git collectors.asd
colleen http://beta.quicklisp.org/archive/colleen/2018-10-18/colleen-20181018-git.tgz 145758 b20ec13f6a9612e0f496af7eccb24f54 950fa71177e3966ae52eb7a986d9ceeeb5e117ed colleen-20181018-git colleen.asd
colliflower http://beta.quicklisp.org/archive/colliflower/2021-10-20/colliflower-20211020-git.tgz 24479 a4f4d0eec6119ea97bcfc93e9845a4fb c02b61ea1e6f1732201ce36d3718c3eab9bce190 colliflower-20211020-git colliflower-test.asd colliflower.asd contrib/fset/colliflower-fset.asd garten/garten.asd liter/liter.asd silo/silo.asd
colored http://beta.quicklisp.org/archive/colored/2021-10-20/colored-20211020-git.tgz 24424 caecccde9bfcf6296229a15ccc9df221 4dbdd2d319e016515ede15e58e3d8db685acfd77 colored-20211020-git colored-test.asd colored.asd
colorize http://beta.quicklisp.org/archive/colorize/2018-02-28/colorize-20180228-git.tgz 39488 1bc08c8f76b747e4d254669a205dc611 e0658fa18ae562a802f987eff7f16a8bc78906f8 colorize-20180228-git colorize.asd
com-on http://beta.quicklisp.org/archive/com-on/2022-03-31/com-on-20220331-git.tgz 18667 9241014453e34b7a4a7f4bdf624cb36b 52de6bd675c28df07b0afda92acd95d0bf44a49f com-on-20220331-git com-on-test.asd com-on.asd
com.clearly-useful.generic-collection-interface http://beta.quicklisp.org/archive/com.clearly-useful.generic-collection-interface/2019-07-10/com.clearly-useful.generic-collection-interface-20190710-git.tgz 14043 b22496129d4171c50de7ab85da024cc0 0dac346508bb07e3237054a0554c2c6d28153020 com.clearly-useful.generic-collection-interface-20190710-git com.clearly-useful.generic-collection-interface.asd com.clearly-useful.generic-collection-interface.test.asd
com.clearly-useful.iterate-plus http://beta.quicklisp.org/archive/com.clearly-useful.iterate-plus/2012-10-13/com.clearly-useful.iterate-plus-20121013-git.tgz 1981 691606442da9344a1b871a986dc83a42 c7a315d2b09d7666def427dc37cad324317caf51 com.clearly-useful.iterate-plus-20121013-git com.clearly-useful.iterate+.asd
com.clearly-useful.iterator-protocol http://beta.quicklisp.org/archive/com.clearly-useful.iterator-protocol/2013-03-12/com.clearly-useful.iterator-protocol-20130312-git.tgz 2846 b6219074982d29677ebf5a7ae1b5a22e 5f9051fdccbd78f3c919112a67acf80587c921d9 com.clearly-useful.iterator-protocol-20130312-git com.clearly-useful.iterator-protocol.asd
com.clearly-useful.protocols http://beta.quicklisp.org/archive/com.clearly-useful.protocols/2013-03-12/com.clearly-useful.protocols-20130312-git.tgz 8625 7a230b991c6f410f2f1f1cc016aa3ae1 174ae8cc771b48bc36f4ae2ee3dfb80fef266d60 com.clearly-useful.protocols-20130312-git com.clearly-useful.protocols.asd
com.google.base http://beta.quicklisp.org/archive/com.google.base/2020-09-25/com.google.base-20200925-git.tgz 7337 ba324012a79d55a6580a6ff84b3f8f88 412c71519922fde0636a7e500cba778d2a67d040 com.google.base-20200925-git com.google.base.asd
command-line-arguments http://beta.quicklisp.org/archive/command-line-arguments/2021-08-07/command-line-arguments-20210807-git.tgz 12294 b50ca36f5b2b19d4322ac5b5969fee22 89849f6f16274954d7d868231ac4066675b74490 command-line-arguments-20210807-git command-line-arguments.asd
common-doc http://beta.quicklisp.org/archive/common-doc/2022-07-07/common-doc-20220707-git.tgz 52949 3fae2b6cbd126d4bb4bff4e4416a3220 3632e56f6cf072dffe55604180ab8f4e03486a68 common-doc-20220707-git common-doc-contrib.asd common-doc-gnuplot.asd common-doc-graphviz.asd common-doc-include.asd common-doc-split-paragraphs.asd common-doc-test.asd common-doc-tex.asd common-doc.asd
common-doc-plump http://beta.quicklisp.org/archive/common-doc-plump/2016-04-21/common-doc-plump-20160421-git.tgz 6172 5e53d47b0bb2ad2d5bc1d6686b1446ba dc865b5fd8705da9ddbb20a44742ec5454679e12 common-doc-plump-20160421-git common-doc-plump-test.asd common-doc-plump.asd
common-html http://beta.quicklisp.org/archive/common-html/2021-08-07/common-html-20210807-git.tgz 7567 d0a2e6256b391c41ad4c999a0617de6e 4ca95dbeb1563737cd0111a71a36e116b55b3bf2 common-html-20210807-git common-html-test.asd common-html.asd
common-lisp-actors http://beta.quicklisp.org/archive/common-lisp-actors/2019-11-30/common-lisp-actors-20191130-git.tgz 4753 890e04c2f7df07e7180cbc7d81ed7bb5 5e927cacbb0fa3a49605423ca50b41626c1af00b common-lisp-actors-20191130-git cl-actors.asd
common-lisp-jupyter http://beta.quicklisp.org/archive/common-lisp-jupyter/2022-11-06/common-lisp-jupyter-20221106-git.tgz 372718 4f1d3423d3522ea71a885b20289b7646 47c7b1b65bb5cc641ac15f63e450580b983986f7 common-lisp-jupyter-20221106-git common-lisp-jupyter.asd
commondoc-markdown http://beta.quicklisp.org/archive/commondoc-markdown/2022-11-06/commondoc-markdown-20221106-git.tgz 11932 04589ee5d7f8ff3ee26bf6a2277b580b 483925a5ef1e239ca214161b2a28dc6612e70611 commondoc-markdown-20221106-git commondoc-markdown-docs.asd commondoc-markdown-test.asd commondoc-markdown.asd
commonqt http://beta.quicklisp.org/archive/commonqt/2020-09-25/commonqt-20200925-git.tgz 61693 2ed2dc0941ea052292348edb07a437f4 408ada31e6aa4ac05792fdb8871459ab6f6eef08 commonqt-20200925-git qt+libs.asd qt-repl.asd qt-test.asd qt-tutorial.asd qt.asd
compatible-metaclasses http://beta.quicklisp.org/archive/compatible-metaclasses/2020-09-25/compatible-metaclasses_1.0.tgz 6709 3b57508fe1be7eb389f8425b48be448a 10bf357724f7981b49ebf9486d2cf26255e2aedc compatible-metaclasses_1.0 compatible-metaclasses.asd tests/compatible-metaclasses_tests.asd
compiler-macro-notes http://beta.quicklisp.org/archive/compiler-macro-notes/2022-11-06/compiler-macro-notes-v0.2.1.tgz 4588 3e8c15fa8f5cc9bf27148588d34a7879 bd3659509b9c606d99b219a759618a3d5b5ac40e compiler-macro-notes-v0.2.1 compiler-macro-notes.asd
computable-reals http://beta.quicklisp.org/archive/computable-reals/2021-04-11/computable-reals-20210411-git.tgz 8812 a84da8fbba157f3f00166d264157471b f7b498c443446c2f13414030fdf3c9b69251f557 computable-reals-20210411-git computable-reals.asd
concrete-syntax-tree http://beta.quicklisp.org/archive/concrete-syntax-tree/2021-10-20/concrete-syntax-tree-20211020-git.tgz 48393 c59c5a6305dfbe48511416974cc7bd35 3dd24ffd6279228e732847d1d18369fe861d5d1b concrete-syntax-tree-20211020-git Destructuring/concrete-syntax-tree-destructuring.asd Lambda-list/Test/concrete-syntax-tree-lambda-list-test.asd Lambda-list/concrete-syntax-tree-lambda-list.asd Source-info/concrete-syntax-tree-source-info.asd concrete-syntax-tree-base.asd concrete-syntax-tree.asd
conduit-packages http://beta.quicklisp.org/archive/conduit-packages/2022-11-06/conduit-packages-20221106-git.tgz 11845 2b22e5c327d61073e49ab72b2fcd4392 5e76df52b283d3a7bcfffce8d934d3daecf8e241 conduit-packages-20221106-git org.tfeb.conduit-packages.asd
conf http://beta.quicklisp.org/archive/conf/2019-12-27/conf-20191227-git.tgz 15652 8b1e1498234b7b4d3ca9cd2f52b66415 9a5e80439fbb82d433465c632c8f901613a4baf5 conf-20191227-git conf.asd
configuration.options http://beta.quicklisp.org/archive/configuration.options/2021-05-31/configuration.options-20210531-git.tgz 126580 4c912b6ef72e59284046fb6a678c9b51 d46ecd01a662a3444f659458e9f88380030f36d2 configuration.options-20210531-git configuration.options-and-mop.asd configuration.options-and-puri.asd configuration.options-and-quri.asd configuration.options-and-service-provider.asd configuration.options-syntax-ini.asd configuration.options-syntax-xml.asd configuration.options.asd
conium http://beta.quicklisp.org/archive/conium/2021-06-30/conium-20210630-git.tgz 146019 15581c5af08715dc394146b912bf7e6f dad0dace4df02e408f9c832caea4d5d6fa24db60 conium-20210630-git conium.asd
consfigurator http://beta.quicklisp.org/archive/consfigurator/2022-11-06/consfigurator-v1.1.1.tgz 211093 9703def5b39510bff060f45652c9b789 96168bca7999337be6c577a6eed62eb5f957f32b consfigurator-v1.1.1 consfigurator.asd
consix http://beta.quicklisp.org/archive/consix/2020-12-20/consix-20201220-git.tgz 15301 149a8f0f26aa7feca43c5b3b8c8226f4 b8d5e5a7cc28c315f87afc79c8ed5baeac3fad90 consix-20201220-git consix.asd
constantfold http://beta.quicklisp.org/archive/constantfold/2019-12-27/constantfold-20191227-git.tgz 135729 e9e0021014c6f27280264be16166fee7 378cbed129d745f65125c9f3931f350e92d61c22 constantfold-20191227-git constantfold.asd constantfold.test.asd
context-lite http://beta.quicklisp.org/archive/context-lite/2022-03-31/context-lite-20220331-git.tgz 11211 2d764e227e0105e5f6835509bb341aca 5d29f5c897e00686aecb282050e60c1f2a3bd58d context-lite-20220331-git context-lite.asd
contextl http://beta.quicklisp.org/archive/contextl/2021-12-30/contextl-20211230-git.tgz 26407 0c7093716e2772f90635bcd3c4d23dc0 fb3b65eda1e4685b0a50096b9d7b89ed941c6d1f contextl-20211230-git contextl.asd dynamic-wind.asd
convolution-kernel http://beta.quicklisp.org/archive/convolution-kernel/2022-07-07/convolution-kernel-20220707-git.tgz 3439 4612ac16d43997d2a349d6f7dcaad100 4c9d508f62fc44acd6e51c048ece507f8f5420fb convolution-kernel-20220707-git convolution-kernel.asd
copy-directory http://beta.quicklisp.org/archive/copy-directory/2016-06-28/copy-directory-20160628-git.tgz 2462 b82455b6979b785df488f990e156aa2b fe74b777a2f899c84de338f3c96b732cc1e2d06c copy-directory-20160628-git copy-directory-test.asd copy-directory.asd
core http://beta.quicklisp.org/archive/core/2021-02-28/core-20210228-git.tgz 14197 6801e17a16ed1537588a23eac014b447 c517ad996aea1741d6e40b99fbe9dbd38e4e6df7 core-20210228-git issr-core.asd
core-reader http://beta.quicklisp.org/archive/core-reader/2022-07-07/core-reader-20220707-git.tgz 6436 367a0c18774e808fbff00c678f8e5c9d b328695606d2ae8fae37a986d273f087018939b8 core-reader-20220707-git core-reader.asd spec/core-reader.test.asd
cover http://beta.quicklisp.org/archive/cover/2021-02-28/cover-20210228-git.tgz 17580 8720e075cb81963143f02345b4c8973c 67072c42f8f58093022fbd01d8c91c5924e21136 cover-20210228-git cover.asd
cqlcl http://beta.quicklisp.org/archive/cqlcl/2014-11-06/cqlcl-20141106-git.tgz 11896 2a63a524e1297e6a2577a29d63bd7ea2 7480e139c03880e1e41bca03ae6fde148a1ce161 cqlcl-20141106-git cqlcl.asd
crane http://beta.quicklisp.org/archive/crane/2016-02-08/crane-20160208-git.tgz 20738 df5119bed5754d9f7811efc770c09d47 d438f1997e83f251bb1b61653a2a0e6a08bccbda crane-20160208-git crane-test.asd crane.asd
cricket http://beta.quicklisp.org/archive/cricket/2022-07-07/cricket-20220707-git.tgz 2171440 4bdd058cd96d7f27438a1f49739a1303 10adc9ce89787f1ff9bcb577d2e47c9022c9b01f cricket-20220707-git cricket.asd cricket.test.asd
croatoan http://beta.quicklisp.org/archive/croatoan/2022-11-06/croatoan-20221106-git.tgz 182775 4edc9e2d0932c9ad52c407e8ba540532 f73e1c30b1e435c02a74cee4ad238eec90dd228d croatoan-20221106-git ansi-escape-test.asd ansi-escape.asd croatoan-ncurses.asd croatoan-test.asd croatoan.asd
crypto-shortcuts http://beta.quicklisp.org/archive/crypto-shortcuts/2020-10-16/crypto-shortcuts-20201016-git.tgz 7169 141f84864a94c775ff02a3f330687ea9 177f4fd261bff45f6dc2e2ce1578fd6c23a2e7b0 crypto-shortcuts-20201016-git crypto-shortcuts.asd
cserial-port http://beta.quicklisp.org/archive/cserial-port/2021-12-30/cserial-port-20211230-git.tgz 12033 2d28224020833fa68ff0ccc143d122aa 5fa26da79734392535782c17f8059684361212c6 cserial-port-20211230-git cserial-port.asd
css-lite http://beta.quicklisp.org/archive/css-lite/2022-11-06/css-lite-20221106-git.tgz 6711 28336a1be3383c804ea8e50462eb45ff 88f2880fc2cc49df0293e288c0d8d94cfd19fca4 css-lite-20221106-git css-lite.asd
css-selectors http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz 14832 28537144b89af4ebe28c2eb365d5569f 67e31993847a16f20b4eda93e1266644a426ff4c css-selectors-20160628-git css-selectors-simple-tree.asd css-selectors-stp.asd css-selectors.asd
csv http://beta.quicklisp.org/archive/csv/2019-07-10/csv-20190710-git.tgz 14041 cecd51e92195eb497c4b20d82c90930a 18cfd80c132c100ddac12ea2f82e9030783e0649 csv-20190710-git csv.asd
csv-parser http://beta.quicklisp.org/archive/csv-parser/2014-07-13/csv-parser-20140713-git.tgz 5012 d8f43b3da734b63f2064b7cd4c6f7550 033d33a6821c836cce4b2299e5ea688807ea12b3 csv-parser-20140713-git csv-parser.asd
ctype http://beta.quicklisp.org/archive/ctype/2022-07-07/ctype-20220707-git.tgz 54522 f90751cc3f8eed71726913a16fa6c804 d0bd1a3260cf70fdd0e9d0d44deb787168b7a012 ctype-20220707-git ctype.asd ext/tfun/ctype-tfun.asd
cubic-bezier http://beta.quicklisp.org/archive/cubic-bezier/2022-07-07/cubic-bezier-20220707-git.tgz 4310 3c10a518022b36edb8836d568e307d37 8b4447b71766be97204c1e6cace9221e1af50419 cubic-bezier-20220707-git cubic-bezier.asd
cue-parser http://beta.quicklisp.org/archive/cue-parser/2018-02-28/cue-parser-20180228-git.tgz 6196 a762d2f16148e031ac658c19bc35fe95 dde1439487e627ca02f8d1e9641fbe40696b45bd cue-parser-20180228-git cue-parser.asd
curly http://beta.quicklisp.org/archive/curly/2012-04-07/curly-20120407-git.tgz 4647 abbdcfe5c08ee02a8f9014373db6fd86 adfe3715c7311e6a27755ca3da84155bcf93641a curly-20120407-git curly.asd
curry-compose-reader-macros http://beta.quicklisp.org/archive/curry-compose-reader-macros/2020-12-20/curry-compose-reader-macros-20201220-git.tgz 5042 69aa0c8998dca3713c1b1200e7abbd9c f6c141be656bf9f9a25f57656a3008e0691e5142 curry-compose-reader-macros-20201220-git curry-compose-reader-macros.asd
curve http://beta.quicklisp.org/archive/curve/2013-01-28/curve-20130128-git.tgz 19617 f4c1a224405586a04d65cac6b38a5ccc 000367ed6ad72b814a533a633506ef30fda97271 curve-20130128-git com.elbeno.curve.asd
cxml http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz 155775 0b6f34edb79f7b63cc5855f18d0d66f0 d2c3fabebd0c6f3ebc6e55533e49081d3abecbd9 cxml-20200610-git cxml-dom.asd cxml-klacks.asd cxml-test.asd cxml.asd
cxml-rng http://beta.quicklisp.org/archive/cxml-rng/2019-07-10/cxml-rng-20190710-git.tgz 173375 ac7fb180022392f6cb689509bc14bab3 4cd12475c54fe7f34510a5d1d5b5fdb9c6403443 cxml-rng-20190710-git cxml-rng.asd
cxml-rpc http://beta.quicklisp.org/archive/cxml-rpc/2012-10-13/cxml-rpc-20121013-git.tgz 11422 58bca5e93a2f2eb5a5451e689b590c2b 0ada3a401ef59cbf83f0d4601b206895913711f6 cxml-rpc-20121013-git cxml-rpc.asd
cxml-stp http://beta.quicklisp.org/archive/cxml-stp/2020-03-25/cxml-stp-20200325-git.tgz 51687 5622b4aae55e448473f1ba14fa3a5f4c f9945b099f0d192db860252500ab335d21dc60e9 cxml-stp-20200325-git cxml-stp.asd
cytoscape-clj http://beta.quicklisp.org/archive/cytoscape-clj/2022-11-06/cytoscape-clj-20221106-git.tgz 49886 4b9d94f3e35addae6adf9cacc2420576 241a757c2b20f617db084c8a3f449a72d65360e2 cytoscape-clj-20221106-git cytoscape-clj.asd
daemon http://beta.quicklisp.org/archive/daemon/2017-04-03/daemon-20170403-git.tgz 4007 97d52817fa74191a6a07a49cd4a5b907 542f44f5a01f0d8bde303167edfa73cd2b5473cb daemon-20170403-git daemon.asd
damn-fast-priority-queue http://beta.quicklisp.org/archive/damn-fast-priority-queue/2022-11-06/damn-fast-priority-queue-20221106-git.tgz 11539 afdffb8b16311a0fcc6e7b8239a8ea0d 5988ebe41d05238c0cd82996b3217f68038cbb1c damn-fast-priority-queue-20221106-git damn-fast-priority-queue/damn-fast-priority-queue.asd damn-fast-stable-priority-queue/damn-fast-stable-priority-queue.asd priority-queue-benchmark/priority-queue-benchmark.asd
dartsclemailaddress http://beta.quicklisp.org/archive/dartsclemailaddress/2016-04-21/dartsclemailaddress-quicklisp-release-48464635-git.tgz 11830 537619b8caa0c43db075a82f732a31ee bc0850e087137a945257bfafdc530b5f256ea5c6 dartsclemailaddress-quicklisp-release-48464635-git darts.lib.email-address-test.asd darts.lib.email-address.asd
dartsclhashtree http://beta.quicklisp.org/archive/dartsclhashtree/2021-12-30/dartsclhashtree-20211230-git.tgz 27145 c85df02fbd8ea960971f7a81251a7bdd 4b670191f83523850dc12f46af7bd72bbbf1faa4 dartsclhashtree-20211230-git darts.lib.hashtree-test.asd darts.lib.hashtrie.asd darts.lib.wbtree.asd
dartsclmessagepack http://beta.quicklisp.org/archive/dartsclmessagepack/2020-03-25/dartsclmessagepack-20200325-git.tgz 8171 781b1622fbdfdd63a2387ffd8e33e78e b96ad4b4d8dd9b34dc8c13c82e5c3df3122208c3 dartsclmessagepack-20200325-git darts.lib.message-pack-test.asd darts.lib.message-pack.asd
dartsclsequencemetrics http://beta.quicklisp.org/archive/dartsclsequencemetrics/2013-03-12/dartsclsequencemetrics-20130312-git.tgz 8234 2440599722cb58ab64d30a687946166b 2a29fa7b05dff2273678b71dff33d1db79af1ff4 dartsclsequencemetrics-20130312-git darts.lib.sequence-metrics.asd
dartscltools http://beta.quicklisp.org/archive/dartscltools/2020-12-20/dartscltools-20201220-git.tgz 15893 795a82fac00eae77a509e69ddda9a843 82626a8adf65344d4104c94a1d1b845c1ca5840b dartscltools-20201220-git darts.lib.tools.asd darts.lib.tools.test.asd
dartscluuid http://beta.quicklisp.org/archive/dartscluuid/2021-08-07/dartscluuid-20210807-git.tgz 7982 0ff35520f90c0015cf6096d11fd37a7f a9978d6778b13db6cca3bdc9b13afa05b6ddf7ac dartscluuid-20210807-git darts.lib.uuid-test.asd darts.lib.uuid.asd
data-frame http://beta.quicklisp.org/archive/data-frame/2022-11-06/data-frame-20221106-git.tgz 559624 41a966b5e91a5c3c5750f4bf01dfb3e2 cada7ae651abfb9af648d5365b6659a3fb15faed data-frame-20221106-git data-frame.asd
data-lens http://beta.quicklisp.org/archive/data-lens/2022-11-06/data-lens-20221106-git.tgz 111732 c93e00fc0544554e7610d583812d4898 1313ab6149b1eb1e12fd94c1cf0d9a3ecdd7c760 data-lens-20221106-git data-lens.asd
data-sift http://beta.quicklisp.org/archive/data-sift/2013-01-28/data-sift-20130128-git.tgz 13070 2d023844d8a181dbbcc69368c3b90a9c 2ca3997e31fd229f29dc332b0a737ab23c62bb62 data-sift-20130128-git data-sift.asd
data-table http://beta.quicklisp.org/archive/data-table/2022-11-06/data-table-20221106-git.tgz 12444 28062b926c411d7a286f68b308ab926d 1e11b5700cd7df50c787debd9f0434b0bf222fb5 data-table-20221106-git data-table-clsql.asd data-table.asd
database-migrations http://beta.quicklisp.org/archive/database-migrations/2018-08-31/database-migrations-20180831-git.tgz 3983 2e3f0877c95e8fc8632a9fe7979bfe82 9c364cc2b74d76a3184be7e4a269e156521ae331 database-migrations-20180831-git database-migrations.asd
datafly http://beta.quicklisp.org/archive/datafly/2020-03-25/datafly-20200325-git.tgz 9722 df50fed8e32a0c5505760b9d8ef51fb0 19e26778d1c2202ab4ec2b919ab0218ea7d3f8f0 datafly-20200325-git datafly-test.asd datafly.asd
dataloader http://beta.quicklisp.org/archive/dataloader/2021-05-31/dataloader-20210531-git.tgz 1978244 3d6df6522022c1c059f28b0346781094 bf51e0d48a20f18bfbbfe348b30e692f0f4eaa03 dataloader-20210531-git dataloader.asd dataloader.test.asd
datamuse http://beta.quicklisp.org/archive/datamuse/2022-11-06/datamuse-20221106-git.tgz 6074 90552bfe497afabec8bd26363f46082e f43300bfd654766060bc7e83bec3083ecb9a1e2c datamuse-20221106-git datamuse.asd
date-calc http://beta.quicklisp.org/archive/date-calc/2019-12-27/date-calc-20191227-git.tgz 10417 fda245d738b350711fb614ba18ee01f4 6e55f21ffcedf6a36c8a212fde29a3ebb9f0ce85 date-calc-20191227-git date-calc.asd
datum-comments http://beta.quicklisp.org/archive/datum-comments/2021-02-28/datum-comments-20210228-git.tgz 8102 8645354f622ea4a2675bdeaa48235487 5830f8ebae8579da885732077a21b7e5b9aab5f6 datum-comments-20210228-git datum-comments.asd
dbus http://beta.quicklisp.org/archive/dbus/2021-10-20/dbus-20211020-git.tgz 23474 f3fb2ad37c197d99d9c446f556a12bdb 52a143655cf6676895be6a78f18c04bb0f5d91e0 dbus-20211020-git dbus.asd
de-mock-racy http://beta.quicklisp.org/archive/de-mock-racy/2022-11-06/de-mock-racy-20221106-git.tgz 3806 1dd1872b5d0cc386f9c9a36e42699889 e63b1c610beec85cb8084502b2bf043ea2edf3db de-mock-racy-20221106-git de-mock-racy.asd
de.setf.wilbur http://beta.quicklisp.org/archive/de.setf.wilbur/2018-12-10/de.setf.wilbur-20181210-git.tgz 77937 76864fbe1ad7bdf810efa74e2bb4765e 3a699742b7b8738c9f8cf51f391e9571f74b9f15 de.setf.wilbur-20181210-git src/wilbur.asd
declt http://beta.quicklisp.org/archive/declt/2022-07-07/declt-4.0b2.tgz 430231 e825346a2d2a09b30837b3999b9ff7e4 ec1e15a2ca9b8d9586a73b7e5a73bdf114eac8ad declt-4.0b2 assess/net.didierverna.declt.assess.asd core/net.didierverna.declt.core.asd net.didierverna.declt.asd setup/net.didierverna.declt.setup.asd
deeds http://beta.quicklisp.org/archive/deeds/2020-07-15/deeds-20200715-git.tgz 35037 4bffe3aaab67c607582657da54bf21b1 7ad8982b1ed00528b5e8e273fb549363b8166ca8 deeds-20200715-git deeds.asd
defclass-std http://beta.quicklisp.org/archive/defclass-std/2020-12-20/defclass-std-20201220-git.tgz 8957 b7a3bec06318b10818dc3941d407fe65 793f16213c536268037e80d85a6ee5844550ac5a defclass-std-20201220-git defclass-std-test.asd defclass-std.asd
defconfig http://beta.quicklisp.org/archive/defconfig/2021-12-09/defconfig-20211209-git.tgz 30885 4a40936c3a8d6673fcee781b31a0329e c16ecb9587cc575a240b1ffbec8503d0331854ba defconfig-20211209-git defconfig.asd
defenum http://beta.quicklisp.org/archive/defenum/2021-12-30/defenum-20211230-git.tgz 12940 6a5cd4b06c3ea38ab194c62ad9018f40 f25ba784f5addf0e6450e312e10cb79aa9eedcf4 defenum-20211230-git defenum.asd
deferred http://beta.quicklisp.org/archive/deferred/2019-07-10/deferred-20190710-git.tgz 5908 0830491b2d6bb9cfbc2a95036b9a7332 438d3927bc5dfe4215aaa39f79207e768ab45444 deferred-20190710-git deferred.asd
define-json-expander http://beta.quicklisp.org/archive/define-json-expander/2014-07-13/define-json-expander-20140713-git.tgz 5026 4f67d0f505ff548d386e3f6f3d24bef9 8ac3161ab7afd1de0a40473d86201b2fff87f17e define-json-expander-20140713-git define-json-expander.asd
definer http://beta.quicklisp.org/archive/definer/2021-12-30/definer-20211230-git.tgz 6256 f82183d897a1f4efaa98b14c0130617f 56d22faa78eaac421ad921bc8aebdea578ea56e5 definer-20211230-git definer.asd
definitions http://beta.quicklisp.org/archive/definitions/2021-05-31/definitions-20210531-git.tgz 19473 cb965c5ff4551b491c4f84b6a2c55adc de0daf2f03e92452d57894365665742d9f0fd6b6 definitions-20210531-git definitions.asd
definitions-systems http://beta.quicklisp.org/archive/definitions-systems/2021-04-11/definitions-systems_2.0.1.tgz 16401 f907e00604c2de021591c58951f0fabf b12995355d78b6bf57ffda02edb0a5a7b6ce9a4c definitions-systems_2.0.1 definitions-systems.asd tests/definitions-systems_tests.asd
deflate http://beta.quicklisp.org/archive/deflate/2020-02-18/deflate-20200218-git.tgz 10271 c82d28eed5b489ced654c7202025e699 e6e719b55fe429157a8c09be0f93a405b02315c3 deflate-20200218-git deflate.asd
defmain http://beta.quicklisp.org/archive/defmain/2022-11-06/defmain-20221106-git.tgz 19429 83ab5098bcc7512548a41997f4a27232 787a8d6015527d5d2bf0ab077b0f1ea406e75779 defmain-20221106-git defmain-test.asd defmain.asd
defmemo http://beta.quicklisp.org/archive/defmemo/2012-04-07/defmemo-20120407-git.tgz 1953 542105d03e8a0d012c21cefffed2f8ad e7d6f9f95ef8866e063c5e35eee1458e6022d7af defmemo-20120407-git defmemo.asd
defpackage-plus http://beta.quicklisp.org/archive/defpackage-plus/2018-01-31/defpackage-plus-20180131-git.tgz 6485 de7af07da901fe5623450d32fd4b7ddc dea6c565dee9b6d821b21a25f4169515e52595df defpackage-plus-20180131-git defpackage-plus.asd
defrec http://beta.quicklisp.org/archive/defrec/2019-03-07/defrec-20190307-hg.tgz 2488 28b1762c6fb45a24487be334d7d5db14 f5ea970dac951fd12455449ba66da09b471596e4 defrec-20190307-hg defrec.asd
defrest http://beta.quicklisp.org/archive/defrest/2021-05-31/defrest-20210531-git.tgz 7560 1840b19b00f3ec4dfd10e900cd3191f0 e03dfe9ebd9641b06b8c478b03ffe0287d24d48e defrest-20210531-git defrest.asd
defstar http://beta.quicklisp.org/archive/defstar/2014-07-13/defstar-20140713-git.tgz 46970 36db8379ba81239923e5f97dba352d8b 2983be99196ad25ad29404af66a6c61b6eca212a defstar-20140713-git defstar.asd
defsystem-compatibility http://beta.quicklisp.org/archive/defsystem-compatibility/2010-10-06/defsystem-compatibility-20101006-darcs.tgz 9848 ad19788379d30f53165b74683deee776 bc441cffe18d811b971e130cfa94b57938e353ec defsystem-compatibility-20101006-darcs defsystem-compatibility-test.asd defsystem-compatibility.asd
defvariant http://beta.quicklisp.org/archive/defvariant/2014-07-13/defvariant-20140713-git.tgz 10059 34cae097b3a510c71aec8638e6244384 8d43269b616dad7f0d0c9a6725e1614cb5c330c2 defvariant-20140713-git defvariant.asd
delorean http://beta.quicklisp.org/archive/delorean/2013-06-15/delorean-20130615-git.tgz 3788 441d44c6c37939df46fc1f6a549f97d6 f9b4b8ed3e1cf9811a32e19fa64f868598baf1c3 delorean-20130615-git delorean.asd
delta-debug http://beta.quicklisp.org/archive/delta-debug/2018-08-31/delta-debug-20180831-git.tgz 5769 0cfd1860910888e5d129e3a134a58e12 28dd1ae4e76fcd381539b1a09622525b083a7830 delta-debug-20180831-git delta-debug.asd
dendrite http://beta.quicklisp.org/archive/dendrite/2017-10-23/dendrite-release-quicklisp-409b1061-git.tgz 5988 574bb8da79376d36fdf04ae254ba04c5 d14f3b6356f3d6443fd76296e6c1ef32036045ca dendrite-release-quicklisp-409b1061-git dendrite.asd dendrite.micro-l-system.asd dendrite.primitives.asd
dense-arrays http://beta.quicklisp.org/archive/dense-arrays/2022-11-06/dense-arrays-20221106-git.tgz 43151 42d941ce04028e9ce0147a3269f8c866 daad4f4dd7d812ed57073f2329259d1b80bc25b2 dense-arrays-20221106-git dense-arrays+cuda.asd dense-arrays+magicl.asd dense-arrays+static-vectors.asd dense-arrays-plus-lite.asd dense-arrays-plus.asd dense-arrays.asd
deoxybyte-gzip http://beta.quicklisp.org/archive/deoxybyte-gzip/2014-01-13/deoxybyte-gzip-20140113-git.tgz 130916 e6e373d376f3598f7ee3792e586a7dc3 53a1f55a7db874c66d5cf1f1ebf0800559e1584e deoxybyte-gzip-20140113-git deoxybyte-gzip-test.asd deoxybyte-gzip.asd
deoxybyte-io http://beta.quicklisp.org/archive/deoxybyte-io/2014-01-13/deoxybyte-io-20140113-git.tgz 40992 7283270d2df168edda80ec15bede2aa3 b4326e35061b6bed2625cb26cf545dd8984cb0e7 deoxybyte-io-20140113-git deoxybyte-io-test.asd deoxybyte-io.asd
deoxybyte-systems http://beta.quicklisp.org/archive/deoxybyte-systems/2014-01-13/deoxybyte-systems-20140113-git.tgz 3677 cb63033baf4ff3c8aaba80252e77f5d6 c306db96a2de41c23f2284164b9577cc1ba2c718 deoxybyte-systems-20140113-git deoxybyte-systems.asd
deoxybyte-unix http://beta.quicklisp.org/archive/deoxybyte-unix/2014-01-13/deoxybyte-unix-20140113-git.tgz 20104 058d5bc317967f587535fae8ee97a39f 6886a7daf781f97173d9cbb8fa84e3229054d260 deoxybyte-unix-20140113-git deoxybyte-unix-test.asd deoxybyte-unix.asd
deoxybyte-utilities http://beta.quicklisp.org/archive/deoxybyte-utilities/2014-01-13/deoxybyte-utilities-20140113-git.tgz 32707 1d29f3a612c1e7901b0fd053cac93f87 d9fa17f1f96255a973fe1c13b0b982197b303220 deoxybyte-utilities-20140113-git deoxybyte-utilities-test.asd deoxybyte-utilities.asd
deploy http://beta.quicklisp.org/archive/deploy/2022-07-07/deploy-20220707-git.tgz 19256 831cd5744655af282dde5e2de18093a1 4fbfa7c5f3bbe4a8510f63a38365361380880625 deploy-20220707-git deploy-test.asd deploy.asd
depot http://beta.quicklisp.org/archive/depot/2022-11-06/depot-20221106-git.tgz 35661 b3b13f1dd00f159f4692dcc248143496 9296b970eb6e5e400f30eddafc870ac74d56d330 depot-20221106-git depot-in-memory.asd depot-virtual.asd depot-zip.asd depot.asd test/depot-test.asd
descriptions http://beta.quicklisp.org/archive/descriptions/2015-03-02/descriptions-20150302-git.tgz 23662 b16c4d4768515759094d08043f6cd181 bae261da6cae337aabc0daa49fbe0f2d399dcecb descriptions-20150302-git descriptions-test.asd descriptions.asd descriptions.serialization.asd descriptions.validation.asd
destructuring-bind-star http://beta.quicklisp.org/archive/destructuring-bind-star/2020-06-10/destructuring-bind-star-20200610-git.tgz 3158 3349d26d971d5e7c26d0f2adaefb1746 a9844ddf811a0c00ade075126908d83f9cb3bc5c destructuring-bind-star-20200610-git destructuring-bind-star.asd
dexador http://beta.quicklisp.org/archive/dexador/2022-11-06/dexador-20221106-git.tgz 213330 50ceeda46b57d4527fc258974df0944a 0f78bd918a1dd7e989f46ef0c5c7f536cc4f3c2b dexador-20221106-git dexador-test.asd dexador.asd
dfio http://beta.quicklisp.org/archive/dfio/2022-11-06/dfio-20221106-git.tgz 282202 3138b88bc472659c819dea7257aca429 6f2271d0b616e191701902eebbfb1fc2092d6b8f dfio-20221106-git dfio.asd
diff http://beta.quicklisp.org/archive/diff/2013-08-13/diff-20130813-git.tgz 16642 c13a4545b12b26e6d99c5535048a435d dc6993e2890a59dd59dad95a098771117396e650 diff-20130813-git diff.asd
diff-match-patch http://beta.quicklisp.org/archive/diff-match-patch/2021-05-31/diff-match-patch-20210531-git.tgz 31781 9c7632f9066afc7926d126676d8e39f2 2281e20cac5a8922567ea4cbc6f4644b126ec6b1 diff-match-patch-20210531-git diff-match-patch.asd
dirt http://beta.quicklisp.org/archive/dirt/2017-10-19/dirt-release-quicklisp-0d13ebc2-git.tgz 5590 c3242835717a9db9c2db803d1b25f545 4ba2d03d1d5fad8f92e2683ac9c86e2d23b31678 dirt-release-quicklisp-0d13ebc2-git dirt.asd
disposable http://beta.quicklisp.org/archive/disposable/2016-02-08/disposable-20160208-git.tgz 1504 dd4e4ff956fb44ed624f8dafcaa4bea5 9ddcaa8fbf5ad43195e179882190fc68d4b58039 disposable-20160208-git disposable.asd
dissect http://beta.quicklisp.org/archive/dissect/2022-11-06/dissect-20221106-git.tgz 28946 5f23b4800d355b4a69f03d459cbcb44d 2ec187734bd9ac41de15b7ade10e86a1e9b1a79f dissect-20221106-git dissect.asd
distributions http://beta.quicklisp.org/archive/distributions/2022-11-06/distributions-20221106-git.tgz 584645 96f25e7e8af97ebf254fdf2b62d4822d 39bb98bb9237cc4d83ee4d811ee885dcb066a237 distributions-20221106-git distributions.asd
djula http://beta.quicklisp.org/archive/djula/2022-07-07/djula-20220707-git.tgz 125674 ff5cca95c63b4b8502be86aafb436bf8 c4378cee1476bbfa4266c71a0d9755b14b564749 djula-20220707-git djula-demo.asd djula-test.asd djula.asd
dlist http://beta.quicklisp.org/archive/dlist/2012-11-25/dlist-20121125-git.tgz 14699 c935ee7e9bf0e30a5fd70ae703195f9e 2b23fc66cf9c4829828d4ef04b61938215c39c0f dlist-20121125-git dlist.asd
dml http://beta.quicklisp.org/archive/dml/2018-10-18/dml-20181018-git.tgz 440514 7423921f88d0a15f12fcba859ff518d9 48be480e302c2dd2151cda1d62ff8df9483c8814 dml-20181018-git dml.asd
dns-client http://beta.quicklisp.org/archive/dns-client/2021-10-20/dns-client-20211020-git.tgz 13614 99619a672f93563d373224315402f745 b9c5ceb764eaad5e41d7a37dc561be72e8a114c4 dns-client-20211020-git dns-client.asd
do-urlencode http://beta.quicklisp.org/archive/do-urlencode/2018-10-18/do-urlencode-20181018-git.tgz 2318 cb6ab78689fe52680ee1b94cd7738b94 7eaef5c9b5cf8dfe004ad3a8fa101bad8193b3f1 do-urlencode-20181018-git do-urlencode.asd
doc http://beta.quicklisp.org/archive/doc/2022-11-06/doc-20221106-git.tgz 2667104 0254ca26b001f7eb7fe892962dced3cc 2c90b0d893a111c9033f130127dfe956b3d77fe0 doc-20221106-git 40ants-doc-full.asd 40ants-doc-test.asd 40ants-doc.asd
docbrowser http://beta.quicklisp.org/archive/docbrowser/2020-06-10/docbrowser-20200610-git.tgz 906050 a28a213648fa0323d08bb145f3f51518 c1934624f9443bc1151a26a41020776508babca4 docbrowser-20200610-git docbrowser.asd
docparser http://beta.quicklisp.org/archive/docparser/2022-11-06/docparser-20221106-git.tgz 13617 e7d64bdde2667aafa5a5d386e6557590 3e6db882c9fd155a988c55247d2f48f88a04dfde docparser-20221106-git docparser-test-system.asd docparser-test.asd docparser.asd
docs-builder http://beta.quicklisp.org/archive/docs-builder/2022-11-06/docs-builder-20221106-git.tgz 17168 e456b3f832bc7fdde2ab1adbc8309573 d09670705f1fb58c06538e68cb723bdbd63fbccc docs-builder-20221106-git docs-builder.asd docs-config.asd
documentation-template http://beta.quicklisp.org/archive/documentation-template/2014-12-17/documentation-template-0.4.4.tgz 8721 847d38e9131779931cb7063e019afe5d 2cd71d1884d3eff7b76a0f907969b986c4125744 documentation-template-0.4.4 documentation-template.asd
documentation-utils http://beta.quicklisp.org/archive/documentation-utils/2019-07-10/documentation-utils-20190710-git.tgz 8913 4f45f511ac55008b8b8aa04f7feaa2d4 1071335af99636f62943713298b46a0244b5bda4 documentation-utils-20190710-git documentation-utils.asd multilang-documentation-utils.asd
documentation-utils-extensions http://beta.quicklisp.org/archive/documentation-utils-extensions/2022-07-07/documentation-utils-extensions-20220707-git.tgz 4593 3ca89cb555a1cae84a875f465e286a10 ab602312fe4a14a34364973f6429aba93f39643f documentation-utils-extensions-20220707-git documentation-utils-extensions.asd
donuts http://beta.quicklisp.org/archive/donuts/2012-07-03/donuts-20120703-git.tgz 1232132 5d3e62b6453941a0bf64741c3df70b54 9c8061bcd3b2dd1443a1bccef991115169137482 donuts-20120703-git donuts.asd
doplus http://beta.quicklisp.org/archive/doplus/2021-10-20/doplus-v1.1.0.tgz 35530 a91f679e16699d4c5ba5e0600b975def aa19d4f0ef0a8f8dff4618ca3a5d90401f729561 doplus-v1.1.0 doplus-fset.asd doplus.asd
dotenv http://beta.quicklisp.org/archive/dotenv/2021-12-09/dotenv-20211209-git.tgz 2498 9dcd62a0e1eee8e4bec1570d83ad3357 cc4bdf4743e2b7443abe8aa6783b1f9ca8d32a84 dotenv-20211209-git dotenv.asd
doubly-linked-list http://beta.quicklisp.org/archive/doubly-linked-list/2022-07-07/doubly-linked-list-20220707-git.tgz 2913 5efd00a98fe512b5ed925e4c264dc1c5 3ba7b9bc474a76ae18b7c36fd0f54ccc4423b59f doubly-linked-list-20220707-git doubly-linked-list.asd
drakma http://beta.quicklisp.org/archive/drakma/2022-07-07/drakma-v2.0.9.tgz 74439 50e0b8ed6f0184851ac6831148861e06 db13f04d181904b2a4ac4f01bbfb84c60e3bb0f9 drakma-v2.0.9 drakma-test.asd drakma.asd
drakma-async http://beta.quicklisp.org/archive/drakma-async/2021-08-07/drakma-async-20210807-git.tgz 21305 89819f7b8bb872d2e8dbd3ecce15517c 949fd03b0e95c3cc1615246621eb4737177cbe7e drakma-async-20210807-git drakma-async.asd
draw-cons-tree http://beta.quicklisp.org/archive/draw-cons-tree/2013-10-03/draw-cons-tree-20131003-git.tgz 2252 ce720e2ddf395246927e5765f5116084 94e6c5794403485da7bce440547e4e5cb59afb92 draw-cons-tree-20131003-git draw-cons-tree.asd
dsm http://beta.quicklisp.org/archive/dsm/2022-11-06/dsm-20221106-git.tgz 20566 6ee22026d6f75a7f3287fbdb9327b827 e4c0233261fbba308971a2afee3a89655efc07ff dsm-20221106-git org.tfeb.dsm.asd
dso-lex http://beta.quicklisp.org/archive/dso-lex/2011-01-10/dso-lex-0.3.2.tgz 16481 fe8a4a6b9689c06f93f19c1b5506132d 2fac198fb75b4db2d2a1eb02479c94c0c3fa255a dso-lex-0.3.2 dso-lex.asd
dso-util http://beta.quicklisp.org/archive/dso-util/2011-01-10/dso-util-0.1.2.tgz 11309 ad11cec0f5a04142bcd5e117e53c7267 d861e27a509cd972ede6c7377fdc93abfa2c727a dso-util-0.1.2 dso-util.asd
dufy http://beta.quicklisp.org/archive/dufy/2021-05-31/dufy-20210531-git.tgz 483552 2114f30dc7988dc418583c4beafc8d8d b2886d03cb179d38169676111e0be29e38d998b6 dufy-20210531-git dufy.asd
dungen http://beta.quicklisp.org/archive/dungen/2022-07-07/dungen-20220707-git.tgz 5438 37ca97e5fd65c0a5c48d2cccf4787b16 43776d53e779483392fda5a400f2b792f7a57b51 dungen-20220707-git dungen.asd
duologue http://beta.quicklisp.org/archive/duologue/2022-07-07/duologue-20220707-git.tgz 7509 4cae3acd54ef9d486f26a45f5361dd9e 1d6568a2b9099ab31f7bd900e45e471723dd4185 duologue-20220707-git duologue-readline.asd duologue.asd
dweet http://beta.quicklisp.org/archive/dweet/2014-12-17/dweet-20141217-git.tgz 3051 68c4fe0638b6f9febe93925d4fd0cc33 b13c3333a955b851ee4286f5bd1583f09e9e8f75 dweet-20141217-git dweet.asd
dynamic-array http://beta.quicklisp.org/archive/dynamic-array/2022-07-07/dynamic-array-20220707-git.tgz 2429 07643a594778365abbf2f61b3d58f856 7b6a0bb10a0e93e2b77ee3714af986b842e187ca dynamic-array-20220707-git dynamic-array.asd
dynamic-classes http://beta.quicklisp.org/archive/dynamic-classes/2013-01-28/dynamic-classes-20130128-git.tgz 7148 a6ed01c4f21df2b6a142328b24ac7ba3 641573761b2d4fab3b17196cc10a9d46486ab495 dynamic-classes-20130128-git dynamic-classes-test.asd dynamic-classes.asd
dynamic-collect http://beta.quicklisp.org/archive/dynamic-collect/2019-03-07/dynamic-collect-20190307-hg.tgz 447578 c182c60ccb418c9f996f2fe48478cfbf 13d9d81f629b6c665753741ffa45b646f7caeb56 dynamic-collect-20190307-hg dynamic-collect.asd
dynamic-mixins http://beta.quicklisp.org/archive/dynamic-mixins/2018-10-18/dynamic-mixins-20181018-git.tgz 2492 8b2072af2b472c2c7bbaf28ff38e43be a389ddf18ddec5f634f28e506e349b83117085eb dynamic-mixins-20181018-git dynamic-mixins.asd
eager-future http://beta.quicklisp.org/archive/eager-future/2010-10-06/eager-future-20101006-darcs.tgz 3181 33ec9918cece34f35f2354e1f94a245c 862750b95d33edacbc73b08a636b9689a6167336 eager-future-20101006-darcs eager-future.asd
eager-future2 http://beta.quicklisp.org/archive/eager-future2/2019-11-30/eager-future2-20191130-git.tgz 26961 72298620b0fb2f874d86d887cce4acf0 70c0531898eddae204d38b0f5f2dd7c9d7381e8b eager-future2-20191130-git eager-future2.asd test.eager-future2.asd
easing http://beta.quicklisp.org/archive/easing/2018-02-28/easing-20180228-git.tgz 4636 775f27d44c58ff05c38ead610168f1ee 2e8889e1e4e5ece9d39b0d1f99cbe7b352b55ace easing-20180228-git easing-demo.asd easing-test.asd easing.asd
easter-gauss http://beta.quicklisp.org/archive/easter-gauss/2022-07-07/easter-gauss-20220707-git.tgz 2588 cef108e15c5dcbb2cc0a7ef798e5398b 137ed8bd0362a9aa21e3fc9f13fb9c43a5074a76 easter-gauss-20220707-git easter-gauss.asd
easy-audio http://beta.quicklisp.org/archive/easy-audio/2022-07-07/easy-audio-20220707-git.tgz 6466092 e70ea3fa1ea827913923336c9a105448 12c5e928816ad36223c84d42c369ee82fa6de1d3 easy-audio-20220707-git easy-audio.asd
easy-bind http://beta.quicklisp.org/archive/easy-bind/2019-02-02/easy-bind-20190202-git.tgz 16880 ee624a12d458bdb17f4b3dfe7772f699 9240ed116049d326453d744303e65213704859c8 easy-bind-20190202-git easy-bind.asd
easy-macros http://beta.quicklisp.org/archive/easy-macros/2022-11-06/easy-macros-20221106-git.tgz 9447 3a5d7083359b6a8ca5a10c46a4ade155 eadf3062cd9a66b60c5572695921cf3da76f684e easy-macros-20221106-git easy-macros.asd
easy-routes http://beta.quicklisp.org/archive/easy-routes/2022-07-07/easy-routes-20220707-git.tgz 10702 d1d9c4ad4146709f02af4e47da70cdc6 a9cfa8244ac98515da0adb16e41dbd4a132383d9 easy-routes-20220707-git easy-routes+djula.asd easy-routes+errors.asd easy-routes.asd
eazy-documentation http://beta.quicklisp.org/archive/eazy-documentation/2021-04-11/eazy-documentation-20210411-git.tgz 19090 c0aa94986efd7c09a6919341d7df9942 2caea416d0bf15c1bbcf2670b194d776f671192f eazy-documentation-20210411-git eazy-documentation.asd
eazy-gnuplot http://beta.quicklisp.org/archive/eazy-gnuplot/2022-03-31/eazy-gnuplot-20220331-git.tgz 8869959 f974f4f53021f4b994f05f12d0061a51 8cdb00f21c28dbe8befb6d11cc15424a506854d3 eazy-gnuplot-20220331-git eazy-gnuplot.asd eazy-gnuplot.test.asd
eazy-process http://beta.quicklisp.org/archive/eazy-process/2020-09-25/eazy-process-20200925-git.tgz 27369 7b244c4cbea0315aa6b7a31a0be74f0e 747d69189f5fd2f385f9bc79a0d707591f553ec0 eazy-process-20200925-git eazy-process.asd eazy-process.test.asd
eazy-project http://beta.quicklisp.org/archive/eazy-project/2019-07-10/eazy-project-20190710-git.tgz 15917 5b365c1ae21d9faf6eb7cfbb79b729cd 1e037cfaa916d41d7192fac829034426042a5bb4 eazy-project-20190710-git eazy-project.asd eazy-project.autoload.asd eazy-project.test.asd
ec2 http://beta.quicklisp.org/archive/ec2/2012-09-09/ec2-20120909-git.tgz 23603 0c6dea76f190aaa25305490b3e048437 d82ca8949aced8d7ef5fe3ca6bc02a1a3f1ab2a7 ec2-20120909-git ec2.asd
ec2-price-finder http://beta.quicklisp.org/archive/ec2-price-finder/2021-05-31/ec2-price-finder-20210531-git.tgz 9377 cb4ab4f8a5abf8933a9dc5cdebe1612d 2f96b6964152f6b85b9a3f18f7fc2468e530bfa1 ec2-price-finder-20210531-git ec2-price-finder.asd
ecclesia http://beta.quicklisp.org/archive/ecclesia/2020-12-20/ecclesia-20201220-git.tgz 22008 fbf2d75b0a0761a7a7c3b9c0d46448cc 3291b514eb6ee9f520e765baef52340c631a3302 ecclesia-20201220-git ecclesia.asd
eclector http://beta.quicklisp.org/archive/eclector/2022-11-06/eclector-20221106-git.tgz 582517 01726d7d9a066d4bb54971726ccecb66 3324bd4f7b03a53c939047a502350d5379af6678 eclector-20221106-git eclector-concrete-syntax-tree.asd eclector.asd
eco http://beta.quicklisp.org/archive/eco/2019-08-13/eco-20190813-git.tgz 6304 f27079c961c837ffc28f4d8c1a5cf81e 386d0cea4efbb4269e6b22d8387e447986c870cd eco-20190813-git eco-test.asd eco.asd
elb-log http://beta.quicklisp.org/archive/elb-log/2015-09-23/elb-log-20150923-git.tgz 6870 5eb6513fd03c1b015b9f215f96ba9d3b bd104f69efa8db03bdade2bf6fe70c61cd4b58e3 elb-log-20150923-git elb-log-test.asd elb-log.asd
electron-tools http://beta.quicklisp.org/archive/electron-tools/2016-04-21/electron-tools-20160421-git.tgz 2560 70ce32f5c79a23cff6c7fef7677422b4 d3de418ea520e7d7e672ad391a5905e1e72efd06 electron-tools-20160421-git electron-tools-test.asd electron-tools.asd
elf http://beta.quicklisp.org/archive/elf/2019-07-10/elf-20190710-git.tgz 473583 7edebf956ba1892304407f475bf6bdfe 6f7a1bfb3c1930c586d374122158c5a28dc34c56 elf-20190710-git elf.asd
enhanced-boolean http://beta.quicklisp.org/archive/enhanced-boolean/2020-03-25/enhanced-boolean_1.0.tgz 5028 24aa7f4177683f02a893ffe8e5b2a4e5 43f6ee1b0a0b2488942308a112f08834c9943968 enhanced-boolean_1.0 enhanced-boolean.asd tests/enhanced-boolean_tests.asd
enhanced-defclass http://beta.quicklisp.org/archive/enhanced-defclass/2021-04-11/enhanced-defclass_2.1.tgz 6691 1b21d4259fdb9f91d686149eec7aed5f 85a57f8f917a11557659370f8dd4a00e0413d869 enhanced-defclass_2.1 enhanced-defclass.asd tests/enhanced-defclass_tests.asd
enhanced-eval-when http://beta.quicklisp.org/archive/enhanced-eval-when/2012-11-25/enhanced-eval-when-1.0.tgz 1875 4cf59d63539f41b7b0c412f6d9e89ff5 48f3d1a21ddb4f8440d0c04f5a2b45da9bb4438c enhanced-eval-when-1.0 enhanced-eval-when.asd
enhanced-find-class http://beta.quicklisp.org/archive/enhanced-find-class/2020-09-25/enhanced-find-class_1.0.tgz 4661 7b8904bdf58b383d483ed273212e9d2b fe2757b8a731e981db65c0924d3309ee60947246 enhanced-find-class_1.0 enhanced-find-class.asd tests/enhanced-find-class_tests.asd
enhanced-multiple-value-bind http://beta.quicklisp.org/archive/enhanced-multiple-value-bind/2012-11-25/enhanced-multiple-value-bind-1.0.1.tgz 2589 a0fdb32762b7bf6a8cd4b04f07bb05a1 cf4a330e2b640e43bb70ff5da1c7ab7fc97e8a19 enhanced-multiple-value-bind-1.0.1 enhanced-multiple-value-bind.asd
enhanced-typep http://beta.quicklisp.org/archive/enhanced-typep/2020-10-16/enhanced-typep_1.0.tgz 5036 3b76ff3c2a922b807e14c6ff7eff610e e9f6896b7a2dfc2cece4dfb398d837d4b56482b1 enhanced-typep_1.0 enhanced-typep.asd tests/enhanced-typep_tests.asd
envy http://beta.quicklisp.org/archive/envy/2022-03-31/envy-20220331-git.tgz 3631 fce038c12272030243cafabf45de9244 a78b2479314ee8792ba45b334534fa124c233e05 envy-20220331-git envy-test.asd envy.asd
eos http://beta.quicklisp.org/archive/eos/2020-09-25/eos-20200925-git.tgz 13140 52b54a9cbaa8a4338c854de1d71e74c9 2dde4ede2de5509a4c90267b19b982fb320ea357 eos-20200925-git eos.asd
epigraph http://beta.quicklisp.org/archive/epigraph/2020-03-25/epigraph-20200325-git.tgz 17381 a4dd6a4a53b79e5d3e011b47c04d1b41 272dd573925ab736630e936a69a2cbf1d505a5c0 epigraph-20200325-git epigraph.asd
equals http://beta.quicklisp.org/archive/equals/2014-08-26/equals-20140826-git.tgz 2963 5acfaaebd7e1a683b3a84f85b7413340 a3321de358488a827d8535e9b947a316b914f5f5 equals-20140826-git equals.asd
erjoalgo-webutil http://beta.quicklisp.org/archive/erjoalgo-webutil/2022-07-07/erjoalgo-webutil-20220707-git.tgz 14396 06d785d80f555306bbdb6feea3cbeafe 151fdde0bfc04f4a5ec77a29b041c902c917d735 erjoalgo-webutil-20220707-git erjoalgo-webutil.asd
ernestine http://beta.quicklisp.org/archive/ernestine/2022-02-20/ernestine-20220220-git.tgz 308041 f4d8abfd3674e048b7fb1e71adf1cae8 fba24c425ec59755674047d42ede6147e4364ae5 ernestine-20220220-git ernestine-tests.asd ernestine.asd
erudite http://beta.quicklisp.org/archive/erudite/2022-11-06/erudite-20221106-git.tgz 348254 489fb78e04e6f273aa8b036e8b6dca26 4cfa9d516757c2dbb0e15e53ed908912a1ede92a erudite-20221106-git erudite-test.asd erudite.asd
escalator http://beta.quicklisp.org/archive/escalator/2020-04-27/escalator-20200427-git.tgz 6724 64b1ada3a35465b5673520453a75a5c3 cec2c796dc47c628737c0abdec31899d12045a0a escalator-20200427-git escalator-bench.asd escalator.asd
esrap http://beta.quicklisp.org/archive/esrap/2022-03-31/esrap-20220331-git.tgz 69216 c43cd171266d086c25b0ded1b37e7ba9 5308f2b3874ec80a4a83e88fea277a0c34742698 esrap-20220331-git esrap.asd
esrap-liquid http://beta.quicklisp.org/archive/esrap-liquid/2016-10-31/esrap-liquid-20161031-git.tgz 35689 7bc12d040919cb5b5da641334a1f23a1 9c8b389cc2c147922bbbc9be7a21c31c06a1b888 esrap-liquid-20161031-git esrap-liquid.asd
esrap-peg http://beta.quicklisp.org/archive/esrap-peg/2019-10-07/esrap-peg-20191007-git.tgz 7824 48d87d3118febeefc23ca3a8dda36fc0 27a86bbcd4eb649ac379c6b9ba0093234f285ff0 esrap-peg-20191007-git esrap-peg.asd
evaled-when http://beta.quicklisp.org/archive/evaled-when/2020-09-25/evaled-when_1.0.tgz 5863 799325d76de68a7c1ee2b232e05ba8b4 584aa9e8de57f2ce6d4f1da14a394b27aa9857c4 evaled-when_1.0 evaled-when.asd tests/evaled-when_tests.asd
event-emitter http://beta.quicklisp.org/archive/event-emitter/2022-03-31/event-emitter-20220331-git.tgz 3335 dc25d6e4e4b7db7c2fdeca0e58530e1f 6cec6c0b090408811da44315971ed36f1ebb5729 event-emitter-20220331-git event-emitter-test.asd event-emitter.asd
event-glue http://beta.quicklisp.org/archive/event-glue/2015-06-08/event-glue-20150608-git.tgz 9282 1aa70e889ffd2a2d01e7ee740c057415 faedf03cac4300b60f270a365e11a4dba5a74789 event-glue-20150608-git event-glue-test.asd event-glue.asd
eventbus http://beta.quicklisp.org/archive/eventbus/2019-12-27/eventbus-20191227-git.tgz 15807 99b4ca9efc30825dd56e77ae6cd5afe3 85c30ca68cb565572b5a5595e5d5a34e8f5e16c4 eventbus-20191227-git eventbus.asd
eventfd http://beta.quicklisp.org/archive/eventfd/2017-11-30/eventfd-20171130-git.tgz 2518 6580eb40265070dc8292ed4c2a137ee8 8fdce2b98e2d7d6d437a73a5de85f882c0c60859 eventfd-20171130-git eventfd.asd
everblocking-stream http://beta.quicklisp.org/archive/everblocking-stream/2018-10-18/everblocking-stream-20181018-git.tgz 887 307e7b6ba7ecb8912492497d7025e1cd 5539bdd086bef5526c4487ce9634239ac7f204b9 everblocking-stream-20181018-git everblocking-stream.asd
evol http://beta.quicklisp.org/archive/evol/2010-10-06/evol-20101006-git.tgz 36040 063813e42d598be1073625c38cc0fc76 de2a0507ad9682b4f783d23d8e579859e5283763 evol-20101006-git evol-test.asd evol.asd
exit-hooks http://beta.quicklisp.org/archive/exit-hooks/2017-04-03/exit-hooks-20170403-git.tgz 3070 9a5c96e590462bd417f1940ce9d374d2 2d5fb7624a86f2efec0106def24306beece56d53 exit-hooks-20170403-git exit-hooks.asd
exponential-backoff http://beta.quicklisp.org/archive/exponential-backoff/2015-01-13/exponential-backoff-20150113-git.tgz 2397 d3e5d082518de0e1d03ad6a8dac63f07 06dea928582daa17b07682a2df406de61205c63e exponential-backoff-20150113-git exponential-backoff.asd
exscribe http://beta.quicklisp.org/archive/exscribe/2020-09-25/exscribe-20200925-git.tgz 30860 403d29d61ca7d9cd1839689dc0f738e7 56b547785ff2d7efa3902f153ca1b333005513fe exscribe-20200925-git exscribe.asd
ext-blog http://beta.quicklisp.org/archive/ext-blog/2016-08-25/ext-blog-20160825-git.tgz 393481 74fbc8b459a0d074c6fd08bbbd644c31 de4620d23fe78be0a39d8768724c86e074365252 ext-blog-20160825-git ext-blog.asd
extended-reals http://beta.quicklisp.org/archive/extended-reals/2018-03-28/extended-reals-20180328-git.tgz 2979 191bca02ac2c4a55ccc98aa6eda82f66 7d1fba685087c2236a5dd24abdc070f1b2394c4b extended-reals-20180328-git extended-reals.asd
extensible-compound-types http://beta.quicklisp.org/archive/extensible-compound-types/2022-11-06/extensible-compound-types-20221106-git.tgz 31516 3467084c2f973e310418b912c59e50fc a0f851df491617c2840e2bc1c1056426d197f9f5 extensible-compound-types-20221106-git extensible-compound-types-cl.asd extensible-compound-types.asd
external-program http://beta.quicklisp.org/archive/external-program/2019-03-07/external-program-20190307-git.tgz 10408 b30fe104c34059506fd4c493fa79fe1a f04bc9e1b3a0eb5b4c017a8799b9483fc10ea0ff external-program-20190307-git external-program.asd
external-symbol-not-found http://beta.quicklisp.org/archive/external-symbol-not-found/2022-02-20/external-symbol-not-found-20220220-git.tgz 3159 136d6bca0936b14334fa9c858981d964 cc8a543a5c0c10d9e43bc979c27a45f345f70c40 external-symbol-not-found-20220220-git external-symbol-not-found.asd
f-underscore http://beta.quicklisp.org/archive/f-underscore/2010-10-06/f-underscore-20101006-darcs.tgz 982 45ef9c0ac1c92d9aba76b69b53cc7838 34c192987ab8b11f9b09ba40098fc696250506e6 f-underscore-20101006-darcs f-underscore.asd
f2cl http://beta.quicklisp.org/archive/f2cl/2020-09-25/f2cl-20200925-git.tgz 2360280 1ab13fc6c048851f87b1ab1bf6e7efa4 dcbd771cc54956865c51a6fd38f3677f1f993f6a f2cl-20200925-git f2cl-asdf.asd f2cl.asd packages/blas-complex.asd packages/blas-hompack.asd packages/blas-package.asd packages/blas-real.asd packages/blas.asd packages/colnew.asd packages/fftpack5-double.asd packages/fftpack5.asd packages/fishpack.asd packages/hompack.asd packages/lapack.asd packages/minpack.asd packages/odepack.asd packages/quadpack.asd packages/toms419.asd packages/toms715.asd packages/toms717.asd
fact-base http://beta.quicklisp.org/archive/fact-base/2018-03-28/fact-base-20180328-git.tgz 9491 86825a1ba98fe3aa2866ec7e3452a371 26a527bafcf2bd38221c9bd737ca15660d0bed9e fact-base-20180328-git fact-base.asd
factory-alien http://beta.quicklisp.org/archive/factory-alien/2022-07-07/factory-alien-20220707-git.tgz 7056 5ba3c92dd6b8120887348c2f0a404f6c 420f697f13705843ef191b133f042b9ab7e0bdcd factory-alien-20220707-git factory-alien.asd
fakenil http://beta.quicklisp.org/archive/fakenil/2020-03-25/fakenil_1.0.tgz 4481 47646ca1e6cb69ec18c0e07f676662a9 e538b79364c0ea03b2e91d8af8193428d3f7b5be fakenil_1.0 fakenil.asd tests/fakenil_tests.asd
fare-csv http://beta.quicklisp.org/archive/fare-csv/2017-12-27/fare-csv-20171227-git.tgz 7223 1d73aaac9fcd86cc5ddb72019722bc2a d7cdb3a2b3ca5b92953201cc8769998fd8ee65de fare-csv-20171227-git fare-csv.asd
fare-memoization http://beta.quicklisp.org/archive/fare-memoization/2018-04-30/fare-memoization-20180430-git.tgz 7571 7446aa643f0e461d960efb673a706dc1 ef47d67c6d76e8e0c829bbd654e27b69e08fef3b fare-memoization-20180430-git fare-memoization.asd
fare-mop http://beta.quicklisp.org/archive/fare-mop/2015-12-18/fare-mop-20151218-git.tgz 2728 4721ff62e2ac2c55079cdd4f2a0f6d4a cd1f7fcd2aa132432f271f43de9cf39aeef37c71 fare-mop-20151218-git fare-mop.asd
fare-quasiquote http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz 15745 7af0a97c445d88acacecfc851496adb3 153f994a7b921ba34be500ec6e8491431f3ab62a fare-quasiquote-20200925-git fare-quasiquote-extras.asd fare-quasiquote-optima.asd fare-quasiquote-readtable.asd fare-quasiquote.asd
fare-scripts http://beta.quicklisp.org/archive/fare-scripts/2021-12-30/fare-scripts-20211230-git.tgz 42194 6318eb3fdf4d5e71a13cb13bcfce82de 8f1cd1b920db21eb1a7aebbe234f9a8e0662cd1a fare-scripts-20211230-git fare-scripts.asd
fare-utils http://beta.quicklisp.org/archive/fare-utils/2017-01-24/fare-utils-20170124-git.tgz 32604 6752362d0c7c03df6576ab2dbe807ee2 e0b139600b7693a13eece65ff148464168ae890b fare-utils-20170124-git fare-utils.asd test/fare-utils-test.asd
fast-generic-functions http://beta.quicklisp.org/archive/fast-generic-functions/2022-02-20/fast-generic-functions-20220220-git.tgz 12702 daae1f0362d70f7c185cf446774fbaa6 d2f6eac0affc149f52c6d8507e279e6267507222 fast-generic-functions-20220220-git code/fast-generic-functions.asd
fast-http http://beta.quicklisp.org/archive/fast-http/2019-10-07/fast-http-20191007-git.tgz 33540 fd43be4dd72fd9bda5a3ecce87104c97 419610a07b0ccf3117378b6fb9b5faa025037d0b fast-http-20191007-git fast-http-test.asd fast-http.asd
fast-io http://beta.quicklisp.org/archive/fast-io/2022-11-06/fast-io-20221106-git.tgz 9680 5a51bb7c1d97e954a5b7a4860a561edb dd2258c3f0d1773b16c4ebbad60327a5fefbb033 fast-io-20221106-git fast-io-test.asd fast-io.asd
fast-websocket http://beta.quicklisp.org/archive/fast-websocket/2022-07-07/fast-websocket-20220707-git.tgz 9134 719480e5198bd8ed98dfdc8695984b49 e29cdf621494420f87524db3fb847db39640f218 fast-websocket-20220707-git fast-websocket-test.asd fast-websocket.asd
feeder http://beta.quicklisp.org/archive/feeder/2021-02-28/feeder-20210228-git.tgz 21362 a4f021712b6b691bf706056e6fa8605e a313929892ce977ad3ba87315515816de6161706 feeder-20210228-git feeder.asd
femlisp http://beta.quicklisp.org/archive/femlisp/2021-04-11/femlisp-20210411-git.tgz 651522 72ae51a21c4235d4b3d93784ab825430 07f6362dcef27435851f30bc946fd90cedb73c21 femlisp-20210411-git external/cl-cpu-affinity/cl-cpu-affinity.asd external/infix/infix.asd src/applications/courses/dealii-tutorial/dealii-tutorial.asd src/contrib/femlisp-picture.asd src/ddo/ddo.asd src/femlisp-ddo/net.scipolis.graphs.asd systems/femlisp-basic.asd systems/femlisp-dictionary.asd systems/femlisp-matlisp.asd systems/femlisp-parallel.asd systems/femlisp.asd
ffa http://beta.quicklisp.org/archive/ffa/2010-10-06/ffa-20101006-git.tgz 79415 5fe81065a6834b2095373667f5d58426 a3d137edc9af56e3ba853082a2b30f59f7bb79b4 ffa-20101006-git ffa.asd
fft http://beta.quicklisp.org/archive/fft/2018-07-11/fft-20180711-git.tgz 4806 06c2d33d8ddd43332dc25ac4ea7f20cc f77ba0a8d9ccf55d8daaebe31a7053e78a2c29c2 fft-20180711-git fft.asd pfft.asd
fiasco http://beta.quicklisp.org/archive/fiasco/2020-06-10/fiasco-20200610-git.tgz 18950 c5a84e4a0a8afe45729cd6e39af772ac 25c6341ba51ec6b1c07a4ed18827f480f8e3fa89 fiasco-20200610-git fiasco.asd
file-attributes http://beta.quicklisp.org/archive/file-attributes/2021-08-07/file-attributes-20210807-git.tgz 9720 ba0c3667061d97674f5b1666bcbc8506 2e6316c21fab28b6035ce0333d073c24db1d4c91 file-attributes-20210807-git file-attributes.asd
file-local-variable http://beta.quicklisp.org/archive/file-local-variable/2016-03-18/file-local-variable-20160318-git.tgz 3725 8c486b517f733978fa3224ae225a5829 ab4f69526c059b17f5262006217f43b17f217358 file-local-variable-20160318-git file-local-variable.asd file-local-variable.test.asd
file-notify http://beta.quicklisp.org/archive/file-notify/2022-07-07/file-notify-20220707-git.tgz 9194 5628b03e83ea1ed5caac5abf1193e7d1 929e11238a37d2ce72afa58883e03c3b516016c1 file-notify-20220707-git file-notify.asd
file-select http://beta.quicklisp.org/archive/file-select/2022-03-31/file-select-20220331-git.tgz 15367 3bdef8f59e0305b8dbdaa335403cf2e6 ebb4b04d3e10c0ba047e73edad28f4f1b503d44d file-select-20220331-git file-select.asd
file-types http://beta.quicklisp.org/archive/file-types/2016-09-29/file-types-20160929-git.tgz 16146 4fd40465a8bde55c444c65bdcb238a95 ef2a666fadb709340caf6340043fc21c157b4ec6 file-types-20160929-git file-types.asd
filesystem-utils http://beta.quicklisp.org/archive/filesystem-utils/2022-11-06/filesystem-utils-20221106-git.tgz 11585 e022f89f793bd74cac113e6dc0359982 5227bf7ba1b1676c8e0113ef39a287ed0a26f482 filesystem-utils-20221106-git filesystem-utils-test.asd filesystem-utils.asd
filter-maker http://beta.quicklisp.org/archive/filter-maker/2022-11-06/filter-maker-20221106-git.tgz 3684 0c6c877db36cf15a7e7e99114d154194 351f37055949ae72d6b752838255a8946240cfa7 filter-maker-20221106-git filter-maker.asd
filtered-functions http://beta.quicklisp.org/archive/filtered-functions/2016-03-18/filtered-functions-20160318-git.tgz 5624 1a30c0712c4750954a9b645bdc6362cc 76f362ebb3655223f646d4be53dcc85572b307a8 filtered-functions-20160318-git filtered-functions.asd
find-port http://beta.quicklisp.org/archive/find-port/2019-07-10/find-port-20190710-git.tgz 2053 50b5558caf3cc39cc6b55142b6630404 2f18aa155913ec653ae88804cab4422e0e05fb23 find-port-20190710-git find-port-test.asd find-port.asd
firephp http://beta.quicklisp.org/archive/firephp/2016-05-31/firephp-20160531-git.tgz 3101 776c31d2d1d29e0f8ddf916d66f57416 354083daca9bc6e502792af81300ebdaf7fbfd1a firephp-20160531-git firephp-tests.asd firephp.asd
first-time-value http://beta.quicklisp.org/archive/first-time-value/2018-12-10/first-time-value-1.0.1.tgz 4590 ad1d225958063396e5260d963ffbb6e3 20c732c8a5b0b32c80b5d23eb1f70e4c98614d0c first-time-value-1.0.1 first-time-value.asd tests/first-time-value_tests.asd
fiveam http://beta.quicklisp.org/archive/fiveam/2022-03-31/fiveam-20220331-git.tgz 24259 d2649f26369c8661c6b4aa6b8852f7aa da0c2cbf784c18a3b576c8611500d256755b9679 fiveam-20220331-git fiveam.asd
fiveam-asdf http://beta.quicklisp.org/archive/fiveam-asdf/2022-11-06/fiveam-asdf-20221106-git.tgz 4165 fa762b026ce0d5e812f974c29f79448e 22552d64d2d0396f32fb9caa6aaddf9d4f2462e8 fiveam-asdf-20221106-git fiveam-asdf.asd
fiveam-matchers http://beta.quicklisp.org/archive/fiveam-matchers/2022-11-06/fiveam-matchers-20221106-git.tgz 10568 0b3b8800a107bbc0c1f4f741943f50df d61ffc9d4f1e1b1c70917d4f1f9604e65a458f1c fiveam-matchers-20221106-git fiveam-matchers.asd
fixed http://beta.quicklisp.org/archive/fixed/2017-01-24/fixed-20170124-git.tgz 12070 738197e9e3f84c000df9f7c270f49401 58f9ec849945c966fa5f539fc7fd3d1ff8178d3d fixed-20170124-git fixed.asd
flac-metadata http://beta.quicklisp.org/archive/flac-metadata/2022-07-07/flac-metadata-20220707-git.tgz 6317 1b98541a33e1f3cc2d26e29ab1ec9dd7 c31bcec3741e8b9c356a6b5be496916db47d92eb flac-metadata-20220707-git flac-metadata.asd
flare http://beta.quicklisp.org/archive/flare/2022-11-06/flare-20221106-git.tgz 58120 37f02a0feecc76a560af5b64e4316370 64ab1d662800fdd1bf65730f796f52af772177c9 flare-20221106-git flare.asd viewer/flare-viewer.asd
flexi-streams http://beta.quicklisp.org/archive/flexi-streams/2022-02-20/flexi-streams-20220220-git.tgz 445922 eb1f06b71bb83512d730bb47225a45cb eb8428c885b6d962563ee43dee5474f34717b8ad flexi-streams-20220220-git flexi-streams-test.asd flexi-streams.asd
flexichain http://beta.quicklisp.org/archive/flexichain/2020-12-20/flexichain-20201220-git.tgz 21690 dae7599a950826a7d5217f1d35671f2d dcd2e4a8f56d88ce17556a8fd1c06ea45d80b237 flexichain-20201220-git flexichain-doc.asd flexichain.asd
float-features http://beta.quicklisp.org/archive/float-features/2022-11-06/float-features-20221106-git.tgz 10996 13f342a53e49d4c9c64bd73a5257771b 92176485b7beb52ed553d9096f0362a96d39211c float-features-20221106-git float-features-tests.asd float-features.asd
floating-point http://beta.quicklisp.org/archive/floating-point/2014-11-06/floating-point-20141106-git.tgz 473538 2ebe55f78c56d8ca5af9d1e0914b6402 b894b79a5fb145795d45488395056efa86277310 floating-point-20141106-git lisp/floating-point.asd test/floating-point-test.asd
floating-point-contractions http://beta.quicklisp.org/archive/floating-point-contractions/2020-12-20/floating-point-contractions-20201220-git.tgz 2548 057bb79a7eadd71229c39e8c39462f5d 3a708896111feaacf450d71478dbebf33ebbb74b floating-point-contractions-20201220-git floating-point-contractions.asd
flow http://beta.quicklisp.org/archive/flow/2020-06-10/flow-20200610-git.tgz 30044 f0767467d5e9bfda6fe5777a26719811 65bcbd5701584d17d3f13411499ad2601ace8a4f flow-20200610-git flow.asd visualizer/flow-visualizer.asd
flute http://beta.quicklisp.org/archive/flute/2018-08-31/flute-20180831-git.tgz 13138 8c312b0e18c10e7f03b81fc19587b786 632821535927afe4fe360af6ffcd6e1f2f6780bc flute-20180831-git flute-test.asd flute.asd
fmt http://beta.quicklisp.org/archive/fmt/2022-03-31/fmt-20220331-git.tgz 15372 03c12c64e2bedc800c2d31ea27390c55 9ae25217c555f7e3fb41b41c0c4744a3b9d63a92 fmt-20220331-git fmt-test.asd fmt-time.asd fmt.asd
fn http://beta.quicklisp.org/archive/fn/2017-10-19/fn-20171019-git.tgz 6936 0e1cfe5f19ceec8966baa3037772d31e 64871b26712de944ff79e1f58b0e7f4952044810 fn-20171019-git fn.asd
focus http://beta.quicklisp.org/archive/focus/2017-04-03/focus-20170403-git.tgz 47354 2be0459474ffdf328f5139164531a46e 84ef144a2ae449c507a5eaa37ef7c4274b15c36d focus-20170403-git core/net.didierverna.focus.core.asd demos/quotation/net.didierverna.focus.demos.quotation.asd flv/net.didierverna.focus.flv.asd net.didierverna.focus.asd setup/net.didierverna.focus.setup.asd
fof http://beta.quicklisp.org/archive/fof/2021-12-30/fof-20211230-git.tgz 24633 4468e4319b85b823049729be328df5f6 55c00c8c5ff1bee64caa45f4d5ab2e47cd62497e fof-20211230-git fof.asd
folio http://beta.quicklisp.org/archive/folio/2013-01-28/folio-20130128-git.tgz 21241 6f675b7346e8fcd492d4fde527eaa5ac bf20129ce9e18991bb60d1e20dc6c489c9529819 folio-20130128-git as/folio.as.asd boxes/folio.boxes.asd collections/folio.collections.asd folio.asd functions/folio.functions.asd
folio2 http://beta.quicklisp.org/archive/folio2/2019-10-07/folio2-20191007-git.tgz 55271 df04ee7b930f3eec45293a26523c2f42 539dca8db49ca54e344e0f6ba902ea3301ecd745 folio2-20191007-git folio2-as-syntax.asd folio2-as-tests.asd folio2-as.asd folio2-boxes-tests.asd folio2-boxes.asd folio2-functions-syntax.asd folio2-functions-tests.asd folio2-functions.asd folio2-make-tests.asd folio2-make.asd folio2-maps-syntax.asd folio2-maps-tests.asd folio2-maps.asd folio2-pairs-tests.asd folio2-pairs.asd folio2-sequences-syntax.asd folio2-sequences-tests.asd folio2-sequences.asd folio2-series-tests.asd folio2-series.asd folio2-taps-tests.asd folio2-taps.asd folio2-tests.asd folio2.asd
font-discovery http://beta.quicklisp.org/archive/font-discovery/2022-11-06/font-discovery-20221106-git.tgz 13753 a14eb3eb36978269552ed3f2b33775ce 4de2c9048d90a7363b8e328fa185f3baeceeba57 font-discovery-20221106-git font-discovery.asd
for http://beta.quicklisp.org/archive/for/2022-11-06/for-20221106-git.tgz 38659 1c7a8a6c950b871ab61e9e127c2a6c39 22d16ed3b022f2bab683053efd5657165565f63f for-20221106-git for.asd
form-fiddle http://beta.quicklisp.org/archive/form-fiddle/2019-07-10/form-fiddle-20190710-git.tgz 5635 2576065de1e3c95751285fb155f5bcf6 a6a057c05e5512f2f8a0a05e336d422646d76b2c form-fiddle-20190710-git form-fiddle.asd
format-string-builder http://beta.quicklisp.org/archive/format-string-builder/2017-01-24/format-string-builder-20170124-git.tgz 5303 4997e60ed7af0f32d1c5b06f19247288 89a375a3ed8fb7c2cb8f1805403ebd1824594138 format-string-builder-20170124-git format-string-builder.asd
formlets http://beta.quicklisp.org/archive/formlets/2016-12-04/formlets-20161204-git.tgz 10598 b630d094fbbb2fe157f7e3a4bd93b648 a034c03549a46f751d65473b2312e55782ecb4d5 formlets-20161204-git formlets-test.asd formlets.asd
fred http://beta.quicklisp.org/archive/fred/2015-09-23/fred-20150923-git.tgz 34873 dbd3a53435f31cd78f4ddc3e74e9b33b 4abfe6150cb271db84a4094e4d7cef1c50a13472 fred-20150923-git fred.asd
freebsd-ffi http://beta.quicklisp.org/archive/freebsd-ffi/2022-07-07/freebsd-ffi-20220707-git.tgz 5200 23b6fb1d4d779814f25574d1206265c0 eb11e36c84f29513d08cd11dbda6952b8acd28d9 freebsd-ffi-20220707-git freebsd-ffi.asd
freebsd-sysctl http://beta.quicklisp.org/archive/freebsd-sysctl/2021-02-28/freebsd-sysctl-20210228-git.tgz 4552 cf7b007e51961e990da29ab5302986ac a109554e19316a70012c3526af859163b0b0569d freebsd-sysctl-20210228-git freebsd-sysctl.asd
freesound http://beta.quicklisp.org/archive/freesound/2021-04-11/freesound-20210411-git.tgz 17703 5dcff875a4ce830da43093a7e4fa5e22 824ca447571cadbf70032fe155b4c40d8a9c4458 freesound-20210411-git freesound.asd
fresnel http://beta.quicklisp.org/archive/fresnel/2022-07-07/fresnel-20220707-git.tgz 267922 c58e9264bd9ddb47ecbb3348ba73cc32 7577412b45c5f7986e4f545af98c3f08bbe04b53 fresnel-20220707-git fresnel.asd
froute http://beta.quicklisp.org/archive/froute/2018-07-11/froute-20180711-git.tgz 6514 fc27a158d568985e863460c9ac816ecf a22f3a153e2c9314db0e08e625e75909687b0347 froute-20180711-git froute.asd
frpc http://beta.quicklisp.org/archive/frpc/2015-10-31/frpc-20151031-git.tgz 140181 c13346249483dd290b8cf22221df05f7 dafa923a87ffc6bc0b0cdbc4f9d81ee2fd140e48 frpc-20151031-git frpc.asd frpcgen.asd
fs-watcher http://beta.quicklisp.org/archive/fs-watcher/2017-11-30/fs-watcher-20171130-git.tgz 2293 98f697c99206be8e728e98414d56c28f fb546e596be903ecec976563d09982a5b3894885 fs-watcher-20171130-git fs-watcher.asd
fset http://beta.quicklisp.org/archive/fset/2020-09-25/fset-20200925-git.tgz 123968 481e7207099c061459db68813e7bf70c 22c728c09fb798785e2671551afb0552ba2aa111 fset-20200925-git fset.asd
fsocket http://beta.quicklisp.org/archive/fsocket/2021-12-30/fsocket-20211230-git.tgz 39339 7ccadb01b3202fddb4cc68b3935b348e d92eb5254ebf4275d52428153e57f27f60af66d7 fsocket-20211230-git fsocket.asd
fsvd http://beta.quicklisp.org/archive/fsvd/2013-12-11/fsvd-20131211-git.tgz 8009 b6459ca9296f6e331cef49ab5580c766 392c65723a931eb2e8a4bd752d7abf95fc818b5a fsvd-20131211-git fsvd.asd
fucc http://beta.quicklisp.org/archive/fucc/2020-04-27/fucc-v0.2.2.tgz 32965 4659497c5933263fb9f090efc2c25eee e8f2f761914357cd2c81f7f5faf110811c50e501 fucc-v0.2.2 fucc-generator.asd fucc-parser.asd
function-cache http://beta.quicklisp.org/archive/function-cache/2018-12-10/function-cache-20181210-git.tgz 12754 c9ed7dd8f103273bd9daa06b5a720944 98e3470ccaccbd88c7dbfe5e77f19cc742446fc1 function-cache-20181210-git function-cache-clsql.asd function-cache.asd
functional-trees http://beta.quicklisp.org/archive/functional-trees/2022-11-06/functional-trees-20221106-git.tgz 206191 17551fc0dd2923d924a3e0ee5d750f34 5dfc60b047a04b8e0fad5583f964f9b96c6c02a5 functional-trees-20221106-git functional-trees.asd
funds http://beta.quicklisp.org/archive/funds/2021-10-20/funds-20211020-git.tgz 7906 53e03e041b5a0886fd8cc8726c45990f 732fe74708ea4efdf3dbbbfd69e5aac77726c863 funds-20211020-git src/funds.asd
fuzzy-match http://beta.quicklisp.org/archive/fuzzy-match/2021-01-24/fuzzy-match-20210124-git.tgz 4039 eb85bfb02035083c0afc1f9fe277f2f3 90711c815346331378d9b351cd82990aa65a17e5 fuzzy-match-20210124-git fuzzy-match.asd
fxml http://beta.quicklisp.org/archive/fxml/2021-02-28/fxml-20210228-git.tgz 840614 b87843aaecd341b14cf060b09b422abf e1e2309c18b07eb7015188ae4f3345c54ca1fb95 fxml-20210228-git fxml.asd
gadgets http://beta.quicklisp.org/archive/gadgets/2022-02-20/gadgets-20220220-git.tgz 26544 53c73f1390a0f7716c0974f0c52979d0 4fcf9a715fe30cd948955233a4f061ae8635fd1f gadgets-20220220-git gadgets.asd test-gadgets.asd
garbage-pools http://beta.quicklisp.org/archive/garbage-pools/2021-01-24/garbage-pools-20210124-git.tgz 45020 6141f22a295ad535669edae4191e1480 2ccc8ef843071e2d0af9707417f95b482d713da0 garbage-pools-20210124-git garbage-pools-test.asd garbage-pools.asd
gcm http://beta.quicklisp.org/archive/gcm/2014-12-17/gcm-20141217-git.tgz 2461 6836ca1144f86e181cc4684a4be58c10 fddbfbef63cfa8f9301405fc5d5ace4a495b6fe5 gcm-20141217-git gcm.asd
geco http://beta.quicklisp.org/archive/geco/2021-02-28/geco-20210228-git.tgz 468060 3ca7ecc09edf1ec1813b871fe105a4e0 94bb815984f33508feee6fdf416098eff53d4353 geco-20210228-git geco.asd
gendl http://beta.quicklisp.org/archive/gendl/2022-07-07/gendl-master-1a957fb2-git.tgz 15342789 84512365996884ae629653cfc55eab12 604cb2bba1320fa2150a9375f1fea9ee64bcbeb5 gendl-master-1a957fb2-git apps/dom/dom.asd apps/geysr/geysr.asd apps/graphs/graphs.asd apps/legacy/ta2/ta2.asd apps/legacy/tasty/tasty.asd apps/translators/translators.asd apps/tree/tree.asd apps/yadd/yadd.asd base/base.asd cl-lite/cl-lite.asd demos/bus/bus.asd demos/ledger/ledger.asd demos/robot/robot.asd demos/wire-world/wire-world.asd gendl-asdf/gendl-asdf.asd gendl.asd geom-base/geom-base.asd glisp/glisp.asd gwl-graphics/gwl-graphics.asd gwl/gwl.asd regression/regression.asd setup-cffi/setup-cffi.asd surf/surf.asd
generalized-reference http://beta.quicklisp.org/archive/generalized-reference/2022-07-07/generalized-reference-20220707-git.tgz 4636 7bfcc801d1a2c1b4b0d2ae9a21f3ee5b 169cb58d24c12c7ad2d359689d3690aa92c28bda generalized-reference-20220707-git generalized-reference.asd
generators http://beta.quicklisp.org/archive/generators/2013-06-15/generators-20130615-git.tgz 4999 e0de3d2f81b7d5802403186012bc37b6 f9df68f27c422f6dcce84f0635a42500ca2d6e39 generators-20130615-git generators.asd
generic-cl http://beta.quicklisp.org/archive/generic-cl/2021-10-20/generic-cl-20211020-git.tgz 104694 ce42f45dd7c5be44de45ee259a46d7b8 8da7991a79f70bb7846c2ebc107ed8a356b6a7e0 generic-cl-20211020-git generic-cl.arithmetic.asd generic-cl.asd generic-cl.collector.asd generic-cl.comparison.asd generic-cl.container.asd generic-cl.internal.asd generic-cl.iterator.asd generic-cl.lazy-seq.asd generic-cl.map.asd generic-cl.math.asd generic-cl.object.asd generic-cl.sequence.asd generic-cl.set.asd generic-cl.util.asd
generic-comparability http://beta.quicklisp.org/archive/generic-comparability/2018-01-31/generic-comparability-20180131-git.tgz 5622 9cc021f7f580a6e4951066f629bc56f3 7ef5b496c236d42f4fdf529ae257a2e99a9e4417 generic-comparability-20180131-git generic-comparability.asd
generic-sequences http://beta.quicklisp.org/archive/generic-sequences/2015-07-09/generic-sequences-20150709-git.tgz 106323 be208c2f1e6ea5ecd39355d24676312c 330178da719e73413c84f11e42170e76cf60b657 generic-sequences-20150709-git generic-sequences-cont.asd generic-sequences-iterate.asd generic-sequences-stream.asd generic-sequences-test.asd generic-sequences.asd
geneva http://beta.quicklisp.org/archive/geneva/2016-12-04/geneva-20161204-git.tgz 28218 6539a3fb3b4d8e6c2f4c8b1193ded5b3 80144517cb11bd17dd0c6e04470faa450855292e geneva-20161204-git geneva-cl.asd geneva-html.asd geneva-latex.asd geneva-mk2.asd geneva-plain-text.asd geneva-tex.asd geneva.asd open-geneva.asd
genhash http://beta.quicklisp.org/archive/genhash/2018-12-10/genhash-20181210-git.tgz 4210 373e52616aa9563899004e5f017cff6b 36a71477e3ddb2de935ff044dbb9bbe38cc48c76 genhash-20181210-git genhash.asd
geodesic http://beta.quicklisp.org/archive/geodesic/2022-03-31/geodesic-20220331-git.tgz 812959 bae4101f6e83fedb729401a69efe3906 28fc9386a0e8d56845ba06aaf45a1486e9f3e5b6 geodesic-20220331-git geodesic.asd
geowkt http://beta.quicklisp.org/archive/geowkt/2020-06-10/geowkt-20200610-git.tgz 152071 9e60104a35566b61ade31c7d6d1b3177 c551261973b18b4270ac13e871af581048579b63 geowkt-20200610-git geowkt-update.asd geowkt.asd
getopt http://beta.quicklisp.org/archive/getopt/2015-09-23/getopt-20150923-git.tgz 5108 adc97a0ae99d65edff231b35862d67dd 001d521ec954ddd8222f708316c04c6e522e2b16 getopt-20150923-git getopt.asd
gettext http://beta.quicklisp.org/archive/gettext/2017-11-30/gettext-20171130-git.tgz 23766 d162cb5310db5011c82ef6343fd280ed 896479742580c8abecf8f47b77c48d56988b3089 gettext-20171130-git gettext-example/gettext-example.asd gettext-tests/gettext-tests.asd gettext.asd
gfxmath http://beta.quicklisp.org/archive/gfxmath/2022-07-07/gfxmath-20220707-git.tgz 37358 0183f53a4998e951bc4ffda7d366ca1c e4feff602038fdf42b7c95216491d5987d4115c4 gfxmath-20220707-git gfxmath.asd gfxmath.test.asd
git-file-history http://beta.quicklisp.org/archive/git-file-history/2016-08-25/git-file-history-20160825-git.tgz 2640 a642d433a7fd6c73b1c81ad21ab5223e 7522386a8d66527f352d2b63c66feab5814769df git-file-history-20160825-git git-file-history-test.asd git-file-history.asd
github-api-cl http://beta.quicklisp.org/archive/github-api-cl/2022-11-06/github-api-cl-20221106-git.tgz 12078 d13c57af51b4997b804c4b546b719288 2d82b5bc5a96a66a682be57026a52213ffbf5d07 github-api-cl-20221106-git example/github-gist-cl/github-gist-api-cl.asd github-api-cl.asd
glacier http://beta.quicklisp.org/archive/glacier/2021-12-09/glacier-20211209-git.tgz 8646 b6395d9e4728f85a79a2e39eff0ba3ac ab30b6b659c1daf8a09b4346b5f5ff9f49bbd2b3 glacier-20211209-git glacier.asd
glad-blob http://beta.quicklisp.org/archive/glad-blob/2020-10-16/glad-blob-stable-git.tgz 324540 e9ec14a1d0e6e676bbda33020a6b73d8 6fbc0658110a397b7e5b6255117e91d9e07b4d30 glad-blob-stable-git glad-blob.asd
glass http://beta.quicklisp.org/archive/glass/2015-07-09/glass-20150709-git.tgz 70206 45acf599d8810960366575efe9e6dae4 49a0edeb8c25222add274d8ec7aebb8416fda42d glass-20150709-git glass.asd
glaw http://beta.quicklisp.org/archive/glaw/2018-02-28/glaw-20180228-git.tgz 1427712 aa341fdc184de0a4be21654af6b95d5a 361ba78fe7b6456b03bf8ab9c49d6330c2e3b52a glaw-20180228-git glaw-examples.asd glaw-imago.asd glaw-sdl.asd glaw.asd
glfw-blob http://beta.quicklisp.org/archive/glfw-blob/2020-10-16/glfw-blob-stable-git.tgz 624786 e089f3cda24bf2842b87fd54a50b7c1e 4262675dffec229416e6bcb6579db1246aaaad50 glfw-blob-stable-git glfw-blob.asd
glisph http://beta.quicklisp.org/archive/glisph/2017-04-03/glisph-20170403-git.tgz 2341692 8fbfbd69a4b60b1cf7456b1a05332d37 9316f601eb05d9db8eebc61a3f0746227ccf1062 glisph-20170403-git glisph-test.asd glisph.asd
glkit http://beta.quicklisp.org/archive/glkit/2020-10-16/glkit-20201016-git.tgz 15290 5d7acb49daa6ba26d15399a65f09ab76 72aaa32c6c62d64da32b9af19dc44c990dd23a1c glkit-20201016-git glkit-examples.asd glkit.asd
global-vars http://beta.quicklisp.org/archive/global-vars/2014-11-06/global-vars-20141106-git.tgz 3581 dd3153ee75c972a80450aa00644b2200 06ef315e35eaf447159303a16827e05cc28af887 global-vars-20141106-git global-vars-test.asd global-vars.asd
glop http://beta.quicklisp.org/archive/glop/2017-10-19/glop-20171019-git.tgz 85964 329610c0ffc7a862ce454d1901895bca 7d196144d503e8bba5a1ea8b4afe1a19927f8ac6 glop-20171019-git glop-test.asd glop.asd
glsl-metadata http://beta.quicklisp.org/archive/glsl-metadata/2022-07-07/glsl-metadata-20220707-git.tgz 14531 d287afea4f066b201c43e9284bb3f5ca 34c115355ba695a03ca1195b44cf3db4115a8833 glsl-metadata-20220707-git glsl-metadata.asd
glsl-packing http://beta.quicklisp.org/archive/glsl-packing/2018-01-31/glsl-packing-20180131-git.tgz 11241 32b129a2f045f76689c253d13aa8c8bc 3d93bc0affd8a6db19ed7397ed211e4499de0eae glsl-packing-20180131-git glsl-packing.asd
glsl-spec http://beta.quicklisp.org/archive/glsl-spec/2019-10-07/glsl-spec-release-quicklisp-f04476f7-git.tgz 133677 52760939a269acce6b2cba8dbde81ef7 4427cd544f8db5028d5acf54c85f55f398d8a8e7 glsl-spec-release-quicklisp-f04476f7-git glsl-docs.asd glsl-spec.asd glsl-symbols.asd
glsl-toolkit http://beta.quicklisp.org/archive/glsl-toolkit/2022-07-07/glsl-toolkit-20220707-git.tgz 36267 faa4695c2f6eec973f7046a8578d1735 0392e0191c704bd5f6f9de89a65c34c56c138aaa glsl-toolkit-20220707-git glsl-toolkit.asd
glu-tessellate http://beta.quicklisp.org/archive/glu-tessellate/2015-06-08/glu-tessellate-20150608-git.tgz 4736 bebb4d2d5c471ecd0c542ea01b7c48ab 38ef8ee019ff2e082ecb7b582ab86ba245fc9b74 glu-tessellate-20150608-git glu-tessellate.asd
glyphs http://beta.quicklisp.org/archive/glyphs/2018-07-11/glyphs-20180711-git.tgz 16354 1b7cd4d3cda79fa8a35148fedf991e11 a14199085a75163efefd17cfce15fb0a6f3bc9ee glyphs-20180711-git glyphs-test.asd glyphs.asd
gooptest http://beta.quicklisp.org/archive/gooptest/2020-09-25/gooptest-20200925-git.tgz 96103 a91ab23c48e301dcfa4f76a4219ecd2e 4e343ac87eac7312ab25e7af87db10f2ec3f4c88 gooptest-20200925-git gooptest.asd
graph http://beta.quicklisp.org/archive/graph/2022-03-31/graph-20220331-git.tgz 29754 267761faff564388f17e674a17e2ed3a ff555723dba4499ea0adea0bbc3c6d485703ec44 graph-20220331-git graph.asd
graylex http://beta.quicklisp.org/archive/graylex/2011-05-22/graylex-20110522-git.tgz 26517 ebed20d32a2ed9bb763adac09a28ee7d be6cbbe39543e51eafbd0aa171353905db8f251a graylex-20110522-git graylex-m4-example.asd graylex.asd
green-threads http://beta.quicklisp.org/archive/green-threads/2014-12-17/green-threads-20141217-git.tgz 7895 6f2ac5dde894abb04e9dbb55c70ee658 61959b4f605a546d4fbe07a6c84f6754e54e9563 green-threads-20141217-git green-threads.asd
grid-formation http://beta.quicklisp.org/archive/grid-formation/2022-07-07/grid-formation-20220707-git.tgz 3674 c0a02056d62ea81fb4ad9f0ea5f2a872 c19be65ce361d9e0cd09220cf881702ed0e239cf grid-formation-20220707-git grid-formation.asd
group-by http://beta.quicklisp.org/archive/group-by/2014-02-11/group-by-20140211-git.tgz 9071 25caa8291d230d98f66bca57a28ee7a5 9f600f78dc04fbfd4a1260427eb3079278ba2932 group-by-20140211-git group-by.asd
grovel-locally http://beta.quicklisp.org/archive/grovel-locally/2018-02-28/grovel-locally-20180228-git.tgz 5896 e99f1dece67838730a8845c7fbbf19c6 c419b568a3d45c9232a2ceae328c099b736472bc grovel-locally-20180228-git grovel-locally.asd
gsll http://beta.quicklisp.org/archive/gsll/2018-08-31/gsll-quicklisp-eeeda841-git.tgz 317981 4b21395e6c4531dc067d00ed10b580e1 de3edd6293d93620c33938c1ca6318ae13b6bdb4 gsll-quicklisp-eeeda841-git gsll.asd
gtirb http://beta.quicklisp.org/archive/gtirb/2021-10-20/gtirb-quicklisp-dd18337d-git.tgz 603702 a9745104318ba92a154d3579ce16c628 159d2820e38ff3da1cf4a321df6d842eeaafec89 gtirb-quicklisp-dd18337d-git cl/gtirb.asd
gtirb-capstone http://beta.quicklisp.org/archive/gtirb-capstone/2022-11-06/gtirb-capstone-20221106-git.tgz 32453 473e2daa4e25f18068e86732d208fc6f 9d7454e1601296caba4f63786d2cfd1840371be1 gtirb-capstone-20221106-git gtirb-capstone.asd
gtirb-functions http://beta.quicklisp.org/archive/gtirb-functions/2022-11-06/gtirb-functions-20221106-git.tgz 24169 ec0f58e4ff0bc099dec7714cc0d2f19b ee904b37006f7aa18b5acc61aeee51a74fd3f5ca gtirb-functions-20221106-git gtirb-functions.asd
gtk-tagged-streams http://beta.quicklisp.org/archive/gtk-tagged-streams/2018-02-28/gtk-tagged-streams-quicklisp-d1c2b827-git.tgz 73541 952070238f59cf17496556a98f04e8f6 7d4a0f5d5895e8eb0ab4f7d0d37547dc7eb211b3 gtk-tagged-streams-quicklisp-d1c2b827-git gtk-tagged-streams.asd
gtwiwtg http://beta.quicklisp.org/archive/gtwiwtg/2022-11-06/gtwiwtg-20221106-git.tgz 39034 ab3882f2316c3113e9628d94c4e01a49 2130e957195721ac5b8566b834136177a62a1921 gtwiwtg-20221106-git gtwiwtg-test.asd gtwiwtg.asd
gtype http://beta.quicklisp.org/archive/gtype/2020-06-10/gtype-20200610-git.tgz 23153 016cdeb04cdc1b700ba9bf0cdeeaa6d4 37953b070441e2f639c9d98e42b96d287ccf6a20 gtype-20200610-git gtype.asd gtype.test.asd
gute http://beta.quicklisp.org/archive/gute/2022-11-06/gute-20221106-git.tgz 67283 63a0375198d77cdf003208d0d33879dd cfe864f7eb308f299b5d5501ddef1a25ddc0f8e2 gute-20221106-git gute.asd
gzip-stream http://beta.quicklisp.org/archive/gzip-stream/2010-10-06/gzip-stream_0.2.8.tgz 12149 6f0c06fdf7ca0c3124593a2b99b69935 fbcd75fd3042c6fb7f33bcd4d7f065e2248a6a38 gzip-stream_0.2.8 gzip-stream.asd
halftone http://beta.quicklisp.org/archive/halftone/2019-07-10/halftone-20190710-git.tgz 5664 8b0e8a4411bd73acac297d124dd4d672 6b80181e4f8e8c2e564df62cf751f0c8d7d2667d halftone-20190710-git halftone.asd
harmony http://beta.quicklisp.org/archive/harmony/2022-11-06/harmony-20221106-git.tgz 44778 e26b2a73a81e99e268fa2124ebbdb779 6d70a7974aa203f51603eb2f147978746f22831a harmony-20221106-git harmony.asd
hash-set http://beta.quicklisp.org/archive/hash-set/2021-12-30/hash-set-20211230-git.tgz 6028 a0b1388d0c4b5b7807a7d21a755c1b4a e2995157731fd6f520101810b7b772e468f133f0 hash-set-20211230-git hash-set-tests.asd hash-set.asd
hash-table-ext http://beta.quicklisp.org/archive/hash-table-ext/2021-10-20/hash-table-ext-20211020-git.tgz 6170 ce4b60acd1825b0b7af90cdf7c0fda39 67eb92c193faa011d4510dc155f4755f7165a46b hash-table-ext-20211020-git hash-table-ext.asd spec/hash-table-ext.test.asd
hashtrie http://beta.quicklisp.org/archive/hashtrie/2021-10-20/hashtrie-20211020-git.tgz 14278 ac825771da8c39a22bb1a196523f977a d95dde455d0fae5e00af7dfcdf232343de417db0 hashtrie-20211020-git hashtrie-tests.asd hashtrie.asd
hdf5-cffi http://beta.quicklisp.org/archive/hdf5-cffi/2018-02-28/hdf5-cffi-20180228-git.tgz 54363 dbe93f460641f2be9a9c1a910d4ef315 f6a7edd796abf4c379fe7e954690e6362d342600 hdf5-cffi-20180228-git hdf5-cffi.asd hdf5-cffi.examples.asd hdf5-cffi.test.asd
heap http://beta.quicklisp.org/archive/heap/2018-10-18/heap-20181018-git.tgz 2871 a2355ef9c113a3335919a45195083951 3c94679187d9a855a343647f8503812c0925f4f9 heap-20181018-git heap.asd
helambdap http://beta.quicklisp.org/archive/helambdap/2022-02-20/helambdap-20220220-git.tgz 571653 f7a071f4df88762d1615203075873b22 6164171103959dab01e0b2cce93cd3fbc80451c9 helambdap-20220220-git helambdap.asd
hermetic http://beta.quicklisp.org/archive/hermetic/2019-10-07/hermetic-20191007-git.tgz 4564 72d6a7322c98bf3040e88bb17b2f8b27 532f1f055d8e3a277a123d6c7304588457c712ec hermetic-20191007-git hermetic.asd
herodotus http://beta.quicklisp.org/archive/herodotus/2022-03-31/herodotus-20220331-git.tgz 7227 6904210cc1e4947e8dca0a246befc83b c70f8f4f27ef128efe10547acb1fc3a5cacfbe60 herodotus-20220331-git herodotus.asd
hh-aws http://beta.quicklisp.org/archive/hh-aws/2015-08-04/hh-aws-20150804-git.tgz 16762 3d1f15d366f2c0b161f5c8b7759f868a 91faf1b47a18eeb129f608a594a43f230a0c10b4 hh-aws-20150804-git hh-aws.asd
hh-redblack http://beta.quicklisp.org/archive/hh-redblack/2015-10-31/hh-redblack-20151031-git.tgz 13091 4c61afc0406a8eacffebc494a1230beb b4f520f58d13ba5fddb22f042944db2dc02cd960 hh-redblack-20151031-git hh-redblack.asd
hh-web http://beta.quicklisp.org/archive/hh-web/2014-11-06/hh-web-20141106-git.tgz 49100 f18080fa53654dac8d77e5ed5d9953ff d40315c8346f3d101c6c3acecb2e3ae24100484a hh-web-20141106-git hh-web.asd
hl7-client http://beta.quicklisp.org/archive/hl7-client/2015-04-07/hl7-client-20150407-git.tgz 3149 ee18a7ef718e2fb389ad27e6dd628d6d ab1915436f9377f698785eacbafbb8615441956e hl7-client-20150407-git hl7-client.asd
hl7-parser http://beta.quicklisp.org/archive/hl7-parser/2016-05-31/hl7-parser-20160531-git.tgz 5154 92fc8f793d674bb661b0363e1721b3d0 388f1e64bb4d2b76818ac0c02299fcab906b5538 hl7-parser-20160531-git hl7-parser.asd
horner http://beta.quicklisp.org/archive/horner/2019-11-30/horner-20191130-git.tgz 4644 8b4eabb5b0d56ba098ac4a21ae82ff60 aee72c11f78279ad81a01703e3110f1fc0b8aff7 horner-20191130-git horner.asd
horse-html http://beta.quicklisp.org/archive/horse-html/2019-10-07/horse-html-20191007-git.tgz 6518 c5ecbddc6a5e3c40d8329d13a2683763 e5ca014c5a7ca7db9e1f24e27d33c0ee016a53fb horse-html-20191007-git horse-html.asd
house http://beta.quicklisp.org/archive/house/2021-01-24/house-20210124-git.tgz 25704 d2cd140ae063dd22dc440f24964d4b58 2d2f03538bf42a98cb22ee000ad454cd0cc3d380 house-20210124-git house.asd
ht-simple-ajax http://beta.quicklisp.org/archive/ht-simple-ajax/2013-04-21/ht-simple-ajax-20130421-git.tgz 10059 2787aebfc9c4d458206d50461f9443ab e1871d0755dbd48151d54c0c0e512f84798b3d4c ht-simple-ajax-20130421-git ht-simple-ajax.asd
html-encode http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-1.2.tgz 3132 67f22483fe6d270b8830f78f285a1016 ce347529dbb02f008c079427bcb1050372cc24e4 html-encode-1.2 html-encode.asd
html-entities http://beta.quicklisp.org/archive/html-entities/2017-10-19/html-entities-20171019-git.tgz 39697 7a71bcd138f1f367f26e26e9c8e3a390 95458f97469288061d505756bc1f1518b37462d7 html-entities-20171019-git html-entities.asd
html-template http://beta.quicklisp.org/archive/html-template/2017-12-27/html-template-20171227-git.tgz 32376 fb77c495914641f5e67e51a370b2d5a3 946ce5d402bb54c60f84acd6c6d7f6590ede40f1 html-template-20171227-git html-template.asd
http-body http://beta.quicklisp.org/archive/http-body/2019-08-13/http-body-20190813-git.tgz 15739 d46ac52643ae7dc148438f84a8107a79 1da29c1f6f6a06a5ab784acad8ebf702ba6c6216 http-body-20190813-git http-body-test.asd http-body.asd
http-get-cache http://beta.quicklisp.org/archive/http-get-cache/2018-02-28/http-get-cache-20180228-git.tgz 3610 807a9feefeed19159ff46c5733e13da6 2c4623119391c1403fd86f5c19e4865839e62e71 http-get-cache-20180228-git http-get-cache.asd
http-parse http://beta.quicklisp.org/archive/http-parse/2015-06-08/http-parse-20150608-git.tgz 30047 89b5449d33d1ad027606259f84b4c282 65a5aa04e2f6761fc87e6f2c7e7182462ebdaf3f http-parse-20150608-git http-parse-test.asd http-parse.asd
http2 http://beta.quicklisp.org/archive/http2/2022-11-06/http2-20221106-git.tgz 55115 1010b2c0afa184418ea6c9a49a9b763c 222e5612a9f29fc303421725dff4c08f1bd436bf http2-20221106-git http2.asd
hu.dwim.asdf http://beta.quicklisp.org/archive/hu.dwim.asdf/2021-12-30/hu.dwim.asdf-stable-git.tgz 6586 20251cb11ed1d151dc7194a010e196a9 ef3c4695c80df1e479d3aa2f403f21abf9ec9b58 hu.dwim.asdf-stable-git hu.dwim.asdf.asd hu.dwim.asdf.documentation.asd
hu.dwim.bluez http://beta.quicklisp.org/archive/hu.dwim.bluez/2021-02-28/hu.dwim.bluez-stable-git.tgz 126719 4bf491c722174924394af2a9d18e4a78 b45470cd633ed756b260b6313ab5cc39f025ea79 hu.dwim.bluez-stable-git hu.dwim.bluez.asd
hu.dwim.common http://beta.quicklisp.org/archive/hu.dwim.common/2015-07-09/hu.dwim.common-20150709-darcs.tgz 3083 fff7f05c24e71a0270021909ca86a9ef 6ff0a62c94fee95b1440b59230f4a9c174d95093 hu.dwim.common-20150709-darcs hu.dwim.common.asd hu.dwim.common.documentation.asd
hu.dwim.common-lisp http://beta.quicklisp.org/archive/hu.dwim.common-lisp/2021-02-28/hu.dwim.common-lisp-stable-git.tgz 2104 4f0c7a375cc55381efdbeb17ef17dd7d 543dbd676d7ff71b9348f37531864a8e923ea66f hu.dwim.common-lisp-stable-git hu.dwim.common-lisp.asd hu.dwim.common-lisp.documentation.asd
hu.dwim.computed-class http://beta.quicklisp.org/archive/hu.dwim.computed-class/2020-04-27/hu.dwim.computed-class-20200427-darcs.tgz 18753 694fb7d3accec9dda74b6a402a3abf46 1cacf6d60db7f83ff1dae5dc0ca7940c315370ab hu.dwim.computed-class-20200427-darcs hu.dwim.computed-class+hu.dwim.logger.asd hu.dwim.computed-class+swank.asd hu.dwim.computed-class.asd hu.dwim.computed-class.documentation.asd hu.dwim.computed-class.test.asd
hu.dwim.debug http://beta.quicklisp.org/archive/hu.dwim.debug/2019-01-07/hu.dwim.debug-20190107-darcs.tgz 6637 18d7d06110fdbd454e350d92cf5f17cc 3ba6fdf418010b6d7dc03d3dc95ec7c4171d6933 hu.dwim.debug-20190107-darcs hu.dwim.debug.asd hu.dwim.debug.documentation.asd hu.dwim.debug.test.asd
hu.dwim.def http://beta.quicklisp.org/archive/hu.dwim.def/2021-12-30/hu.dwim.def-stable-git.tgz 20120 701fd28dce4536e91607fe5d2e1e8164 e92f3f8ce0017fd12884d415bb7457c301989dc0 hu.dwim.def-stable-git hu.dwim.def+cl-l10n.asd hu.dwim.def+contextl.asd hu.dwim.def+hu.dwim.common.asd hu.dwim.def+hu.dwim.delico.asd hu.dwim.def+swank.asd hu.dwim.def.asd
hu.dwim.defclass-star http://beta.quicklisp.org/archive/hu.dwim.defclass-star/2021-12-30/hu.dwim.defclass-star-stable-git.tgz 9114 4ea430dc53b6fdca3de78bb18ec04d31 065ad41c55e830ec95bf379b2f36a3353a154641 hu.dwim.defclass-star-stable-git hu.dwim.defclass-star+contextl.asd hu.dwim.defclass-star+hu.dwim.def+contextl.asd hu.dwim.defclass-star+hu.dwim.def.asd hu.dwim.defclass-star+swank.asd hu.dwim.defclass-star.asd
hu.dwim.delico http://beta.quicklisp.org/archive/hu.dwim.delico/2020-09-25/hu.dwim.delico-20200925-darcs.tgz 20008 7964d11beb354a681cbc0afa7900137d 007fb702d1a8440bd01d162d0bd2d44cfd712219 hu.dwim.delico-20200925-darcs hu.dwim.delico.asd
hu.dwim.graphviz http://beta.quicklisp.org/archive/hu.dwim.graphviz/2021-12-30/hu.dwim.graphviz-stable-git.tgz 11051 916b3aa7645700d77ec22d0fa399b216 0a593a0f96fbf0eb7ddb836352ae556abb282837 hu.dwim.graphviz-stable-git hu.dwim.graphviz.asd hu.dwim.graphviz.documentation.asd hu.dwim.graphviz.test.asd
hu.dwim.logger http://beta.quicklisp.org/archive/hu.dwim.logger/2021-12-30/hu.dwim.logger-stable-git.tgz 11234 8ad8efcd986ced0f2098bd8ab513efc8 887c4a4d7457f2137fc0587512ab4adfb2803bf7 hu.dwim.logger-stable-git hu.dwim.logger+iolib.asd hu.dwim.logger+swank.asd hu.dwim.logger.asd hu.dwim.logger.documentation.asd hu.dwim.logger.test.asd
hu.dwim.partial-eval http://beta.quicklisp.org/archive/hu.dwim.partial-eval/2017-11-30/hu.dwim.partial-eval-20171130-darcs.tgz 24393 78c498a3ba353e0a62e15df49a459078 9acbc3ab6c50c1104c94047ef747456a7cffd854 hu.dwim.partial-eval-20171130-darcs hu.dwim.partial-eval.asd hu.dwim.partial-eval.documentation.asd hu.dwim.partial-eval.test.asd
hu.dwim.perec http://beta.quicklisp.org/archive/hu.dwim.perec/2021-12-09/hu.dwim.perec-20211209-darcs.tgz 183255 fe2a06da153d00644fc95d01e43e28f4 444641fc74b2f047322cf73f3b1b101ce4d2fc30 hu.dwim.perec-20211209-darcs hu.dwim.perec+hu.dwim.quasi-quote.xml.asd hu.dwim.perec+iolib.asd hu.dwim.perec+swank.asd hu.dwim.perec.all.asd hu.dwim.perec.all.test.asd hu.dwim.perec.asd hu.dwim.perec.documentation.asd hu.dwim.perec.oracle.asd hu.dwim.perec.oracle.test.asd hu.dwim.perec.postgresql.asd hu.dwim.perec.postgresql.test.asd hu.dwim.perec.sqlite.asd hu.dwim.perec.sqlite.test.asd hu.dwim.perec.test.asd
hu.dwim.presentation http://beta.quicklisp.org/archive/hu.dwim.presentation/2021-12-30/hu.dwim.presentation-20211230-darcs.tgz 1733335 7dc89ecd6e3879e05b911bea6be06f22 306be570acd9d585870a40e8cd98dabd72b66083 hu.dwim.presentation-20211230-darcs hu.dwim.presentation+cl-graph+cl-typesetting.asd hu.dwim.presentation+cl-typesetting.asd hu.dwim.presentation+hu.dwim.stefil.asd hu.dwim.presentation+hu.dwim.web-server.asd hu.dwim.presentation.asd
hu.dwim.quasi-quote http://beta.quicklisp.org/archive/hu.dwim.quasi-quote/2022-07-07/hu.dwim.quasi-quote-stable-git.tgz 71987 5f44f32a432b7ba2b187305816020319 3c273ec2815e148dfb91794f6e7989efd55261d6 hu.dwim.quasi-quote-stable-git hu.dwim.quasi-quote.asd hu.dwim.quasi-quote.css.asd hu.dwim.quasi-quote.js.asd hu.dwim.quasi-quote.pdf.asd hu.dwim.quasi-quote.xml+cxml.asd hu.dwim.quasi-quote.xml+hu.dwim.quasi-quote.js.asd hu.dwim.quasi-quote.xml.asd
hu.dwim.rdbms http://beta.quicklisp.org/archive/hu.dwim.rdbms/2020-10-16/hu.dwim.rdbms-20201016-darcs.tgz 117059 3f48287deedd67d720e8efca191e59c8 502e3f86922ac59525ecd485d92137c6f66e4b82 hu.dwim.rdbms-20201016-darcs hu.dwim.rdbms.all.asd hu.dwim.rdbms.all.test.asd hu.dwim.rdbms.asd hu.dwim.rdbms.documentation.asd hu.dwim.rdbms.oracle.asd hu.dwim.rdbms.oracle.test.asd hu.dwim.rdbms.postgresql.asd hu.dwim.rdbms.postgresql.test.asd hu.dwim.rdbms.sqlite.asd hu.dwim.rdbms.sqlite.test.asd hu.dwim.rdbms.test.asd
hu.dwim.reiterate http://beta.quicklisp.org/archive/hu.dwim.reiterate/2021-12-30/hu.dwim.reiterate-stable-git.tgz 21555 c5d5e3b756b9739bd1c2b696f63c50ca 7796b68b1a0f5cde5d88fd94ac6c51ff3b1d852d hu.dwim.reiterate-stable-git hu.dwim.reiterate+hu.dwim.logger.asd hu.dwim.reiterate.asd
hu.dwim.sdl http://beta.quicklisp.org/archive/hu.dwim.sdl/2022-07-07/hu.dwim.sdl-stable-git.tgz 399503 b41d5d2cfdf354cd63d3826cbf52c06a a9bb0690261782727d599c4849e3a04a7b0f79cd hu.dwim.sdl-stable-git hu.dwim.sdl.asd
hu.dwim.serializer http://beta.quicklisp.org/archive/hu.dwim.serializer/2016-12-04/hu.dwim.serializer-20161204-darcs.tgz 12092 bb15ef778eca814e4f1caa5ae05fb7ad 197e6d4df639b4bbd976e819b3247d20a937bb5e hu.dwim.serializer-20161204-darcs hu.dwim.serializer.asd hu.dwim.serializer.documentation.asd hu.dwim.serializer.test.asd
hu.dwim.stefil http://beta.quicklisp.org/archive/hu.dwim.stefil/2021-12-30/hu.dwim.stefil-stable-git.tgz 23318 5340af8dbdd9035275cbf12861b5b2d4 7a0ae61ecfc96ea89af55d9d404485976f8233d5 hu.dwim.stefil-stable-git hu.dwim.stefil+hu.dwim.def+swank.asd hu.dwim.stefil+hu.dwim.def.asd hu.dwim.stefil+swank.asd hu.dwim.stefil.asd
hu.dwim.syntax-sugar http://beta.quicklisp.org/archive/hu.dwim.syntax-sugar/2016-12-04/hu.dwim.syntax-sugar-20161204-darcs.tgz 19274 c155225d3a2b9a329adfcb705b915a91 2f4c5e896d05181efcf0debf1741ac3e0e2fca06 hu.dwim.syntax-sugar-20161204-darcs hu.dwim.syntax-sugar.asd hu.dwim.syntax-sugar.documentation.asd hu.dwim.syntax-sugar.test.asd
hu.dwim.uri http://beta.quicklisp.org/archive/hu.dwim.uri/2018-02-28/hu.dwim.uri-20180228-darcs.tgz 8543 0e3408935a77c74a944f9a34dae3e728 f26121022ce365911e2ab03d8de2af07b8ec2a2d hu.dwim.uri-20180228-darcs hu.dwim.uri.asd hu.dwim.uri.test.asd
hu.dwim.util http://beta.quicklisp.org/archive/hu.dwim.util/2021-12-30/hu.dwim.util-stable-git.tgz 50837 62ee64d5aa5cfd150f5f471cd976427f cda775a73c88d0c87d118f84b4f8edf74dba6b22 hu.dwim.util-stable-git hu.dwim.util+iolib.asd hu.dwim.util.asd hu.dwim.util.documentation.asd hu.dwim.util.test.asd
hu.dwim.walker http://beta.quicklisp.org/archive/hu.dwim.walker/2022-07-07/hu.dwim.walker-stable-git.tgz 38345 9bda13e6955344ec81314600a2678180 5d2955d3e2fc7a772e4538d158b3f73dc08c7641 hu.dwim.walker-stable-git hu.dwim.walker.asd
hu.dwim.web-server http://beta.quicklisp.org/archive/hu.dwim.web-server/2022-07-07/hu.dwim.web-server-20220707-darcs.tgz 512106 5231bd8d4a141c311a9499e9cdca59f4 5ea06cc4f0da7957222b950572c3973ebb765c95 hu.dwim.web-server-20220707-darcs hu.dwim.web-server+swank.asd hu.dwim.web-server.application+hu.dwim.perec.asd hu.dwim.web-server.application.asd hu.dwim.web-server.application.test.asd hu.dwim.web-server.asd hu.dwim.web-server.documentation.asd hu.dwim.web-server.test.asd hu.dwim.web-server.websocket.asd
hu.dwim.zlib http://beta.quicklisp.org/archive/hu.dwim.zlib/2022-07-07/hu.dwim.zlib-stable-git.tgz 166624 09e1d2478a6761783cf56ecea016ab9e 563866fc67ae0682235ee0972ac2e0be7e9cb1d5 hu.dwim.zlib-stable-git hu.dwim.zlib.asd
huffman http://beta.quicklisp.org/archive/huffman/2018-10-18/huffman-20181018-git.tgz 2956 195c5722536473cadd283336008bab57 a458727ba8a5e188ecc18e64544836e83fab9b24 huffman-20181018-git huffman.asd
humbler http://beta.quicklisp.org/archive/humbler/2019-07-10/humbler-20190710-git.tgz 48317 a24a0968292724abb594d0a114e61e73 94ec67e5fe60b158d713497084db49be582d1b3d humbler-20190710-git humbler.asd
hunchenissr http://beta.quicklisp.org/archive/hunchenissr/2021-10-20/hunchenissr-20211020-git.tgz 20596 d2c18637372e30da511c44bee25f2e98 f33e3f237eb783620f4420b880c9611d99915c02 hunchenissr-20211020-git issr.asd
hunchensocket http://beta.quicklisp.org/archive/hunchensocket/2022-11-06/hunchensocket-20221106-git.tgz 12566 363a4c591b2523d1c4cda95bfc4f6f9b 9ccdf556ba3f53ccbf3f37e5b66d1fba39235775 hunchensocket-20221106-git hunchensocket.asd
hunchentools http://beta.quicklisp.org/archive/hunchentools/2016-12-04/hunchentools-20161204-git.tgz 5310 3e4c00484a54fce107969941aa695e35 81c5f8bed80dd333cbc1be69da3bb2c752d7ebf9 hunchentools-20161204-git hunchentools.asd
hunchentoot http://beta.quicklisp.org/archive/hunchentoot/2020-06-10/hunchentoot-v1.3.0.tgz 269060 b1bb0c8df41a0ffaba4309e5084930fe dd8922ee966104ffc6fe917392a4c407fb259935 hunchentoot-v1.3.0 hunchentoot.asd
hunchentoot-auth http://beta.quicklisp.org/archive/hunchentoot-auth/2014-01-13/hunchentoot-auth-20140113-git.tgz 5878 f6763dbbfd1f5421e46ff3e9648eeef6 fffbfd821814f8460262143be04c16db0d5f29f7 hunchentoot-auth-20140113-git hunchentoot-auth.asd
hunchentoot-cgi http://beta.quicklisp.org/archive/hunchentoot-cgi/2014-02-11/hunchentoot-cgi-20140211-git.tgz 4322 e300c5959f7100b7e032066239d82541 bf8b301b9f4a99a4ef2237581df81f2d848349a4 hunchentoot-cgi-20140211-git hunchentoot-cgi.asd
hunchentoot-errors http://beta.quicklisp.org/archive/hunchentoot-errors/2022-11-06/hunchentoot-errors-20221106-git.tgz 3799 c9089871cebf2a319334fd1d596e6a04 0cbfce6048cac80aa3b31aba58a3fe485f8a9c4d hunchentoot-errors-20221106-git hunchentoot-errors.asd
hunchentoot-multi-acceptor http://beta.quicklisp.org/archive/hunchentoot-multi-acceptor/2022-03-31/hunchentoot-multi-acceptor-20220331-git.tgz 6438 ba94cc00bcf2bb529506658482439124 c9cd50301d03b08810165de62dcb44f7f25126e2 hunchentoot-multi-acceptor-20220331-git hunchentoot-multi-acceptor.asd
hunchentoot-single-signon http://beta.quicklisp.org/archive/hunchentoot-single-signon/2013-11-11/hunchentoot-single-signon-20131111-git.tgz 2279 52b6a4438e7c63209f674eadba35168c a67c2e3a07f00cf2738ac14400ebdc44868195dc hunchentoot-single-signon-20131111-git hunchentoot-single-signon.asd
hyperluminal-mem http://beta.quicklisp.org/archive/hyperluminal-mem/2021-06-30/hyperluminal-mem-20210630-git.tgz 89747 2fb46423a7db72ed722d674f72f1e21f a2de72c1979a50dc1d1a76dd01d07f340532a06c hyperluminal-mem-20210630-git hyperluminal-mem-test.asd hyperluminal-mem.asd
hyperobject http://beta.quicklisp.org/archive/hyperobject/2020-10-16/hyperobject-20201016-git.tgz 44260 db496f42ae9221ae6be6f5f5c97dbe00 7a218757b838fcdc7437afcc1d00e430919e57bc hyperobject-20201016-git hyperobject.asd
hyperspec http://beta.quicklisp.org/archive/hyperspec/2018-12-10/hyperspec-20181210-git.tgz 23892 742d80f89020e90234f1b8b6f00a3056 4bafc32c2cfd86b013525385e98ec7fa6a6a32c7 hyperspec-20181210-git hyperspec.asd
ia-hash-table http://beta.quicklisp.org/archive/ia-hash-table/2016-03-18/ia-hash-table-20160318-git.tgz 4491 59a825b5b809aabb5ac5db96728756b7 e23c512d4ab5c06fe31cda3fddad17e88981d2c5 ia-hash-table-20160318-git ia-hash-table.asd ia-hash-table.test.asd
iclendar http://beta.quicklisp.org/archive/iclendar/2019-07-10/iclendar-20190710-git.tgz 88066 4ce57c1359648e497fb25962ec2c0594 0bbc2d371b1f87d4077dff0e978f29dc9ebeca50 iclendar-20190710-git iclendar.asd
id3v2 http://beta.quicklisp.org/archive/id3v2/2016-02-08/id3v2-20160208-git.tgz 3963 427ec2cf9a5f8a8be20a663c336c2288 523e03187ec89b0ce2fe95c9bb9dd1376b6856e4 id3v2-20160208-git id3v2-test.asd id3v2.asd
identifier-pool http://beta.quicklisp.org/archive/identifier-pool/2022-07-07/identifier-pool-20220707-git.tgz 2661 119a294ad9ca186e135ef4ff0b18b22c 8dbdccab28258d9e4d5f39829a707b8536b74b7a identifier-pool-20220707-git identifier-pool.asd
idna http://beta.quicklisp.org/archive/idna/2012-01-07/idna-20120107-git.tgz 6242 85b91a66efe4381bf116cdb5d2b756b6 a32def3834b2130ace95c31af82c6c8b92365c53 idna-20120107-git idna.asd
ieee-floats http://beta.quicklisp.org/archive/ieee-floats/2022-02-20/ieee-floats-20220220-git.tgz 5274 91237afb503d64fc7164cf7776a203ba 29fc28be8d5d8601da8c8e6cf91c437a4cdbc53f ieee-floats-20220220-git ieee-floats.asd
illogical-pathnames http://beta.quicklisp.org/archive/illogical-pathnames/2016-08-25/illogical-pathnames-20160825-git.tgz 6071 386d2b1c0a4f280a52841f4a58ddfad2 dce6a9935768ed7323f4744e9d42752aa52af3d2 illogical-pathnames-20160825-git illogical-pathnames.asd
illusion http://beta.quicklisp.org/archive/illusion/2018-08-31/illusion-20180831-git.tgz 5591 e29adc45f1e630a68b7a2594ce8e1d38 b3edb224814b92f42bdc85f76cfda22fb4a61caf illusion-20180831-git illusion-test.asd illusion.asd
image http://beta.quicklisp.org/archive/image/2012-01-07/image-20120107-git.tgz 12334 f6e1bdabba64a9be1f31602ef87b993c f54562f11b8c6b005a480974bf6742c3dff33864 image-20120107-git image.asd
imago http://beta.quicklisp.org/archive/imago/2022-11-06/imago-20221106-git.tgz 2834853 679cd42b28f8641712d902ae3e502a4f 15778c2889f2fee08695c2485806c55400c2368f imago-20221106-git imago.asd
immutable-struct http://beta.quicklisp.org/archive/immutable-struct/2015-07-09/immutable-struct-20150709-git.tgz 2413 dd68ea45a64bd739e733aa2bcf59955c cca9b233fdb9c441fd02a0015a91b982b34978be immutable-struct-20150709-git immutable-struct.asd
in-nomine http://beta.quicklisp.org/archive/in-nomine/2022-11-06/in-nomine-20221106-git.tgz 14169 8d13092238697298d61c9d1adfe51438 4741c807403d57b3cc92c243295fee7471ce7305 in-nomine-20221106-git in-nomine.asd
incf-cl http://beta.quicklisp.org/archive/incf-cl/2019-07-10/incf-cl-20190710-git.tgz 14029 d517885c08a3c9ab7ab0f56071660ed4 4c29c854fba0610eb9f8adc42b99a1e15bff8bfe incf-cl-20190710-git incf-cl.asd
incognito-keywords http://beta.quicklisp.org/archive/incognito-keywords/2013-01-28/incognito-keywords-1.1.tgz 3817 4759f96fbe4f7873f52d126cec3d5b51 d01f0962811264cea7a3ae1abcc510fd0b177d07 incognito-keywords-1.1 incognito-keywords.asd
incongruent-methods http://beta.quicklisp.org/archive/incongruent-methods/2013-03-12/incongruent-methods-20130312-git.tgz 7171 9e41e9a0a9f33e4f9a00b7d525d8d9c2 73424d66cec5c544ac1fd30729d4357ee2ede37a incongruent-methods-20130312-git incongruent-methods.asd
inferior-shell http://beta.quicklisp.org/archive/inferior-shell/2020-09-25/inferior-shell-20200925-git.tgz 11666 7ca5f15446ef80715758610a930bccba 757798da28183ea6b886b5fb62a35cd8d30e954b inferior-shell-20200925-git inferior-shell.asd
infix-dollar-reader http://beta.quicklisp.org/archive/infix-dollar-reader/2012-10-13/infix-dollar-reader-20121013-git.tgz 2671 b94e744bb2cb69b22b8ca1b94711372c 76156fbe2d0f809d57a8fb74355b4cd9a25c1272 infix-dollar-reader-20121013-git infix-dollar-reader-test.asd infix-dollar-reader.asd
infix-math http://beta.quicklisp.org/archive/infix-math/2021-10-20/infix-math-20211020-git.tgz 7169 7f0932b0022937a0428b28bce52ce213 ea2bdbb2e223090a3bfa40f4bb120ab4dab730f9 infix-math-20211020-git infix-math.asd
infix-reader http://beta.quicklisp.org/archive/infix-reader/2022-11-06/infix-reader-20221106-git.tgz 1835 d996a03915f2b4d98bb0dcffef98b992 13bb76c41e2c37845dcbde99e7216c2f65c0744e infix-reader-20221106-git infix-reader.asd
inheriting-readers http://beta.quicklisp.org/archive/inheriting-readers/2021-01-24/inheriting-readers_1.0.1.tgz 9755 862b1f430463ea86be015e8cfd8f1838 187adf91e3c234a114f60e05541fac9736529c4b inheriting-readers_1.0.1 inheriting-readers.asd tests/inheriting-readers_tests.asd
injection http://beta.quicklisp.org/archive/injection/2016-05-31/injection-20160531-git.tgz 16529 fd550866b59e2f852a7457318435cc54 3688d8be08eecc9140e2f6141e94490409227a54 injection-20160531-git injection-test.asd injection.asd
inkwell http://beta.quicklisp.org/archive/inkwell/2019-07-10/inkwell-20190710-git.tgz 19455 80965d4bd6e377146f684c9f55dcdb50 a0e229d7125c2995ae6c28b1e2ce600d59c506da inkwell-20190710-git inkwell.asd
inlined-generic-function http://beta.quicklisp.org/archive/inlined-generic-function/2019-05-21/inlined-generic-function-20190521-git.tgz 13775 e9336f83fe941d4188063d5b8a1daee2 ddb708a3730c99fe766c6f7412119a1c828bd1a3 inlined-generic-function-20190521-git inlined-generic-function.asd inlined-generic-function.test.asd
inner-conditional http://beta.quicklisp.org/archive/inner-conditional/2020-09-25/inner-conditional-20200925-git.tgz 14654 b37d9771f6a619e011699d6e3d06a004 a01047f3e9b44dc46a117ac1d10f4ace51c2bad0 inner-conditional-20200925-git inner-conditional-test.asd inner-conditional.asd
inotify http://beta.quicklisp.org/archive/inotify/2015-06-08/inotify-20150608-git.tgz 3569 185ac26e780c2d0426b261fbbccca12a fce1a600d8dfddb1193e9ee71b0df2d58a2fe288 inotify-20150608-git inotify.asd
input-event-codes http://beta.quicklisp.org/archive/input-event-codes/2022-11-06/input-event-codes-20221106-git.tgz 24929 41a5f1e223e399af02a2be625a9a45b2 7cad6482e267fe3581db22eb21709dba53ac9ba2 input-event-codes-20221106-git input-event-codes.asd
inquisitor http://beta.quicklisp.org/archive/inquisitor/2019-05-21/inquisitor-20190521-git.tgz 938309 b3ccd374ca6d78db990605fa34ca9e6f d9c38ed218610dd382652062ca3ddb5787d82906 inquisitor-20190521-git inquisitor-flexi-test.asd inquisitor-flexi.asd inquisitor-test.asd inquisitor.asd
instance-tracking http://beta.quicklisp.org/archive/instance-tracking/2022-11-06/instance-tracking-20221106-git.tgz 2785 3232a2a52edad76bfc5c9c9914f8a312 cd8632f3dbc6730bcc01003e26c232c6ca039e77 instance-tracking-20221106-git instance-tracking.asd
integral http://beta.quicklisp.org/archive/integral/2020-03-25/integral-20200325-git.tgz 24608 046f587c11865e55a1a52302ea4ea22d 05f11859c3e63f38007c5d101914235bbd962ac9 integral-20200325-git integral-test.asd integral.asd
integral-rest http://beta.quicklisp.org/archive/integral-rest/2015-09-23/integral-rest-20150923-git.tgz 5803 335875a5465c16346cd29689873dc643 97379a1ff7b2b586b9f3bc8070f70be0009d7487 integral-rest-20150923-git integral-rest-test.asd integral-rest.asd
intel-hex http://beta.quicklisp.org/archive/intel-hex/2016-03-18/intel-hex-20160318-git.tgz 5977 0558406788710ac04f4493a66deb2ebe 43cece1a8cf9a6d2b3b574e95a94a9f6825f5ce0 intel-hex-20160318-git intel-hex-test.asd intel-hex.asd
intercom http://beta.quicklisp.org/archive/intercom/2013-06-15/intercom-20130615-git.tgz 32404 9188e4147f75529e5d5e24561d5c6c4e 953a7a49ab8700823c352a0a488486bc2a80f392 intercom-20130615-git lisp/intercom-examples.asd lisp/intercom.asd
interface http://beta.quicklisp.org/archive/interface/2019-03-07/interface-20190307-hg.tgz 8186 2171f1127f13b79c82c56302b629c18b cbe7051bcbdb6fda388369eb1b31717a38217751 interface-20190307-hg interface.asd
introspect-environment http://beta.quicklisp.org/archive/introspect-environment/2022-02-20/introspect-environment-20220220-git.tgz 9695 e2a9864b2f9792f31ad20b44ea25a58b bbd4206f09550c5dfb9342c44ab849ea51074e20 introspect-environment-20220220-git introspect-environment-test.asd introspect-environment.asd
iolib http://beta.quicklisp.org/archive/iolib/2021-06-30/iolib-v0.8.4.tgz 248092 5650165890f8b278b357864f597b377d 907f838a179fef49cf4618bc507cb9fe20733e22 iolib-v0.8.4 iolib.asd iolib.asdf.asd iolib.base.asd iolib.common-lisp.asd iolib.conf.asd iolib.examples.asd
ip-interfaces http://beta.quicklisp.org/archive/ip-interfaces/2018-12-10/ip-interfaces-0.2.1.tgz 14797 c85e479e1eb4139f8996b335e7d0e034 573b6f8413bdfe11863e649f8aa3ec990662c1b8 ip-interfaces-0.2.1 ip-interfaces-test.asd ip-interfaces.asd
irc-logger http://beta.quicklisp.org/archive/irc-logger/2015-09-23/irc-logger-20150923-git.tgz 10393 6d6b60c0d2ac53575ee5c644beb162c3 1b39d7fad92c3ef94747f9be086c567c1dd317bb irc-logger-20150923-git irc-logger.asd
ironclad http://beta.quicklisp.org/archive/ironclad/2022-11-06/ironclad-v0.58.tgz 1539309 9d0a5411443b1b3ad6829ef040fbafd0 08420f8bd0b9004217672734d935cecf3604231e ironclad-v0.58 ironclad-text.asd ironclad.asd
iso-8601-date http://beta.quicklisp.org/archive/iso-8601-date/2019-01-07/iso-8601-date-20190107-git.tgz 4440 b1ab5921a442d86bb2727b4a2bc9e8e0 f927777c79967a5afa2a419b5ef222a8817b9af7 iso-8601-date-20190107-git eclecticse.iso-8601-date.asd
iterate http://beta.quicklisp.org/archive/iterate/2021-05-31/iterate-release-b0f9a9c6-git.tgz 346126 0b2661e9b8195f3e5891aa14601e5a69 f3782561af0bc743648435277ad6d8bafd5d335c iterate-release-b0f9a9c6-git iterate.asd
iterate-clsql http://beta.quicklisp.org/archive/iterate-clsql/2013-03-12/iterate-clsql-20130312-http.tgz 2704 0950d7a9b29b8ddb9d16b45b9096bdae 8f74118d5f989b73db760bcb0a794e23fa185a0a iterate-clsql-20130312-http iterate-clsql.asd
jenkins http://beta.quicklisp.org/archive/jenkins/2013-03-12/jenkins-20130312-git.tgz 15878 53049d3dd8dfe5ea36738005c786f8d0 f3a1fad4ff41d91901a8fe5484bbb2b5df746119 jenkins-20130312-git jenkins.api.asd
jingoh http://beta.quicklisp.org/archive/jingoh/2022-07-07/jingoh-20220707-git.tgz 90998 498fb32c6e9cb4fb1f04fb5958fb31e5 35ad9c2d09d554fb0174a4f75af0ea8938e01ae0 jingoh-20220707-git documentizer/jingoh.documentizer.asd documentizer/spec/jingoh.documentizer.test.asd examiner/jingoh.examiner.asd examiner/spec/jingoh.examiner.test.asd generator/jingoh.generator.asd generator/spec/jingoh.generator.test.asd jingoh.asd org/jingoh.org.asd org/spec/jingoh.org.test.asd parallel/jingoh.parallel.asd parallel/spec/jingoh.parallel.test.asd reader/jingoh.reader.asd reader/spec/jingoh.reader.test.asd tester/jingoh.tester.asd tester/spec/jingoh.tester.test.asd
jonathan http://beta.quicklisp.org/archive/jonathan/2020-09-25/jonathan-20200925-git.tgz 161447 27cad3c107544f587f9f33295c10d81e 83d396bc184d7dc3258910c5785552f7bc5d489f jonathan-20200925-git jonathan-test.asd jonathan.asd
jose http://beta.quicklisp.org/archive/jose/2022-03-31/jose-20220331-git.tgz 14839 695e1cb1943a3304d8bb9044836c351e 2de09eb11de917d6888455a78b555f6564515b82 jose-20220331-git jose.asd
journal http://beta.quicklisp.org/archive/journal/2022-03-31/journal-20220331-git.tgz 163101 df25349e59656389a6e0db30a6b6b926 4720bd9413588c2671ff2b7e2c776c42bb49c696 journal-20220331-git journal.asd
jp-numeral http://beta.quicklisp.org/archive/jp-numeral/2022-11-06/jp-numeral-20221106-git.tgz 42086 27c8108ee07b3d41d12720ed0e25c10c 6559a621c1cc18730f22828c962960d2ebc7223e jp-numeral-20221106-git jp-numeral-test.asd jp-numeral.asd
jpeg-turbo http://beta.quicklisp.org/archive/jpeg-turbo/2020-12-20/jpeg-turbo-20201220-git.tgz 9904 1f516f53239cd39b0ba2a52b845b6380 51744509973a5e45a7442c817c0a086749724c81 jpeg-turbo-20201220-git jpeg-turbo.asd
jpl-queues http://beta.quicklisp.org/archive/jpl-queues/2010-10-06/jpl-queues-0.1.tgz 15113 7c3d14c955db0a5c8ece2b9409333ce0 39497c7cb7292433b5c5a83d7ceb7a6e09cac7b1 jpl-queues-0.1 jpl-queues.asd
js http://beta.quicklisp.org/archive/js/2018-01-31/js-20180131-git.tgz 64836 52f3ec4406ac27a84b65be99ebda51e0 85b589dc6d059502fb56c7b265121ff36712cf19 js-20180131-git cl-js.asd
js-parser http://beta.quicklisp.org/archive/js-parser/2015-04-07/js-parser-20150407-git.tgz 67870 4b86296f7eb3542447528822f7fa2612 4b2e27dfa07c730235c2014740b4d91540d0f656 js-parser-20150407-git js-parser-tests.asd js-parser.asd
json-lib http://beta.quicklisp.org/archive/json-lib/2022-11-06/json-lib-20221106-git.tgz 31768 3373e6cc8fff62f62879a87d258aab9d f6a9cc4dcf8ccee539e104b8290a7a78d5d112f3 json-lib-20221106-git json-lib.asd
json-mop http://beta.quicklisp.org/archive/json-mop/2021-04-11/json-mop-20210411-git.tgz 7526 af57f1dbd2ab596bbbc0281a19a17de7 82ead13180f57dbd54974a251387f9ceebfa08dc json-mop-20210411-git json-mop.asd tests/json-mop-tests.asd
json-responses http://beta.quicklisp.org/archive/json-responses/2019-03-07/json-responses-20190307-hg.tgz 4722 27b0c30fe8df35ecbaa2a7e860191dc1 393cfe5d2254c49fb28ad2ba24a95d3ee5d26c89 json-responses-20190307-hg json-responses.asd
json-schema http://beta.quicklisp.org/archive/json-schema/2022-11-06/json-schema-20221106-git.tgz 111976 7e6c59c6fb8df47f60e47d5c2e9c6ef4 58a8324902d1acf0977c2a7a86740eb4fe158de5 json-schema-20221106-git json-schema.asd
json-streams http://beta.quicklisp.org/archive/json-streams/2017-10-19/json-streams-20171019-git.tgz 45679 b5ab07dce6bfa17782384ecd66bba4bc 8cc35c603b9fdef5e94b82da5dbb72f3551f5530 json-streams-20171019-git json-streams-tests.asd json-streams.asd
jsonrpc http://beta.quicklisp.org/archive/jsonrpc/2022-11-06/jsonrpc-20221106-git.tgz 11674 68de8c436def96ee12b8be3b398c156b cdd28f26c98a0e6b5263891e3267727607f43886 jsonrpc-20221106-git jsonrpc.asd
jsown http://beta.quicklisp.org/archive/jsown/2020-02-18/jsown-20200218-git.tgz 14981 ecf8bfcc2a2ccbab9baddca6592b34ba 2517e044a05b10514cd820cc76c15232273ee46d jsown-20200218-git jsown.asd tests/jsown-tests.asd
jsown-utils http://beta.quicklisp.org/archive/jsown-utils/2022-07-07/jsown-utils-20220707-git.tgz 3142 fd5f9abb01b1ae8111d79a42ce77c7d3 8fa3828bdbfb65f5496dde65c746fc26509cb164 jsown-utils-20220707-git jsown-utils.asd
jwacs http://beta.quicklisp.org/archive/jwacs/2018-02-28/jwacs-20180228-git.tgz 202732 9f9d92d2e616fddc3ceac0e5be375f8d 4e367cb507f1095f53b90aa52dab4b5ac83451f7 jwacs-20180228-git jwacs-tests.asd jwacs.asd
kebab http://beta.quicklisp.org/archive/kebab/2015-06-08/kebab-20150608-git.tgz 3165 b7136a488e5f7f202fd74c59516cac8e 7ba2ed7c0f2ed1ebc31f7c9776563257a5c12bdb kebab-20150608-git kebab-test.asd kebab.asd
kekule-clj http://beta.quicklisp.org/archive/kekule-clj/2022-11-06/kekule-clj-20221106-git.tgz 19944 0758aeaa123b39b599ed787667696c93 512c1da0b7f2159e2f8304c261fa828f32749619 kekule-clj-20221106-git kekule-clj.asd
kenzo http://beta.quicklisp.org/archive/kenzo/2020-03-25/kenzo-20200325-git.tgz 5286328 089acff0dbf9e5dc39491c803d2f79db 118c3900b45bc21760448060b7c6af87987d918f kenzo-20200325-git kenzo-test.asd kenzo.asd
keystone http://beta.quicklisp.org/archive/keystone/2020-04-27/keystone-20200427-git.tgz 4379942 cad54fc8c5b1b4b33e3c912f41f67947 47bffaaa0ed3fb22a6183bd6af0c2f9e98856acb keystone-20200427-git bindings/common-lisp/keystone.asd
kl-verify http://beta.quicklisp.org/archive/kl-verify/2012-09-09/kl-verify-20120909-git.tgz 1728 fd742a26d44433617cf60ded1b4954ac 573e3cde43bc677f4a5da6e76dc7d53923319c1f kl-verify-20120909-git kl-verify.asd
km http://beta.quicklisp.org/archive/km/2011-05-22/km-2-5-33.tgz 328656 f4ba865c0342c5cf8ebcb507becc5e56 57b80fb82b4ea580882fae61c663c79ba3e864ee km-2-5-33 km.asd
kmrcl http://beta.quicklisp.org/archive/kmrcl/2020-10-16/kmrcl-20201016-git.tgz 56206 f86bc410907f748c3c453469702755b8 cc08a0ff889ee59b6c063f8f0e8123df28f795c8 kmrcl-20201016-git kmrcl.asd
l-math http://beta.quicklisp.org/archive/l-math/2019-03-07/l-math-20190307-git.tgz 46344 1d72a81ab46e4ebfda1c749ca67a0e90 a5a68998c4bfebdf452c4d4386fab465051c7eb4 l-math-20190307-git l-math.asd
l-system http://beta.quicklisp.org/archive/l-system/2018-02-28/l-system-20180228-git.tgz 13953 d42ca0e95be4d4cb4390e62119ac7934 89f30dbbdbc8a60a242abc5c63f1daf7851691c8 l-system-20180228-git l-system-examples.asd l-system.asd
laap http://beta.quicklisp.org/archive/laap/2017-08-30/laap-20170830-git.tgz 15178 5d86b49f328d314cdf22a5bda9565f1a 8e90156c16ad1a0ff95b9f29bc8828bee5123101 laap-20170830-git laap.asd
lack http://beta.quicklisp.org/archive/lack/2022-11-06/lack-20221106-git.tgz 181442 54d8fca1ca8dca029b168281d3e48189 f179bc82796dcf581cc4b1fdae6c93ab06a33710 lack-20221106-git lack-app-directory.asd lack-app-file.asd lack-component.asd lack-middleware-accesslog.asd lack-middleware-auth-basic.asd lack-middleware-backtrace.asd lack-middleware-csrf.asd lack-middleware-mount.asd lack-middleware-session.asd lack-middleware-static.asd lack-request.asd lack-response.asd lack-session-store-dbi.asd lack-session-store-redis.asd lack-test.asd lack-util-writer-stream.asd lack-util.asd lack.asd t-lack-component.asd t-lack-middleware-accesslog.asd t-lack-middleware-auth-basic.asd t-lack-middleware-backtrace.asd t-lack-middleware-csrf.asd t-lack-middleware-mount.asd t-lack-middleware-session.asd t-lack-middleware-static.asd t-lack-request.asd t-lack-session-store-dbi.asd t-lack-session-store-redis.asd t-lack-util.asd t-lack.asd
lake http://beta.quicklisp.org/archive/lake/2022-02-20/lake-20220220-git.tgz 21240 c9d4a105bd1bdecff09d44bc15181dbe 0ee04eb1c6ca671b5ea0bf7461df82881603bc6d lake-20220220-git lake-cli.asd lake-test.asd lake.asd
lambda-fiddle http://beta.quicklisp.org/archive/lambda-fiddle/2021-10-20/lambda-fiddle-20211020-git.tgz 6287 89c1c5a2066775e728e4b8051f67d932 ca2321b9acbdccc0bc3a16e5d513a608c54596a6 lambda-fiddle-20211020-git lambda-fiddle.asd
lambda-reader http://beta.quicklisp.org/archive/lambda-reader/2017-01-24/lambda-reader-20170124-git.tgz 3905 f2d0b70125707b31f1975a58b6c3523e e96b520a862982bb8bb801dca92c7ee744c8588a lambda-reader-20170124-git lambda-reader-8bit.asd lambda-reader.asd
lambdalite http://beta.quicklisp.org/archive/lambdalite/2014-12-17/lambdalite-20141217-git.tgz 6077 77d34562c5527b0b771d923704e74420 b1334d9c1402362a9c3aeb17f0c53f065bbec9bb lambdalite-20141217-git lambdalite.asd
language-codes http://beta.quicklisp.org/archive/language-codes/2021-05-31/language-codes-20210531-git.tgz 68791 d6fbb263eac07da83aaa9c30be725c13 af59c9db5089af642763246cac118a75d1108c1c language-codes-20210531-git language-codes.asd
lass http://beta.quicklisp.org/archive/lass/2021-10-20/lass-20211020-git.tgz 23039 46867eddf3d360a2c46f756537f9a2c4 5ecc81d09b4b05ccf5915048578ad88b9476c65a lass-20211020-git binary-lass.asd lass.asd
lass-flexbox http://beta.quicklisp.org/archive/lass-flexbox/2016-02-08/lass-flexbox-20160208-git.tgz 3151 7307dc8d1b5133e50ebb930d6a754edc a45b8c9e8663e6d99d48dc86a6799c4e50d78466 lass-flexbox-20160208-git lass-flexbox-test.asd lass-flexbox.asd
lassie http://beta.quicklisp.org/archive/lassie/2014-07-13/lassie-20140713-git.tgz 11181 3cd995df3ef888663c6a2237567cac27 f7398a93be3c19ae0e84a9b22d06638f56e6cf95 lassie-20140713-git lassie.asd
lastfm http://beta.quicklisp.org/archive/lastfm/2019-10-07/lastfm-20191007-git.tgz 7538 dc29a7688ade882f2c65396d2086f9b9 9a4b61c1bed6af4fbacbf4ab77207409dbc349b5 lastfm-20191007-git lastfm.asd
latex-table http://beta.quicklisp.org/archive/latex-table/2018-03-28/latex-table-20180328-git.tgz 44576 9f102a30b9f31cda67570fdf37c11401 b7f7e7b83296ca127278daa932dd6b9377393e76 latex-table-20180328-git latex-table.asd
latter-day-paypal http://beta.quicklisp.org/archive/latter-day-paypal/2022-11-06/latter-day-paypal-20221106-git.tgz 13342 65295d784368087618da801534b9e471 2645e8eea6938021bf9d962e283b0feb36bbcc6a latter-day-paypal-20221106-git latter-day-paypal.asd
lazy http://beta.quicklisp.org/archive/lazy/2020-09-25/lazy-20200925-git.tgz 1558 e3cd53c9f9ad7d84dd972d70e1c196b1 c61b4f710ea0119ad690cf6cfb7817583ae0b2c6 lazy-20200925-git lazy.asd
legion http://beta.quicklisp.org/archive/legion/2021-10-20/legion-20211020-git.tgz 6145 157c8c5cb74d26a72372c40506e82fa7 36929bd08eaadcc5f2619758409e265e406d27c8 legion-20211020-git legion-test.asd legion.asd
legit http://beta.quicklisp.org/archive/legit/2021-10-20/legit-20211020-git.tgz 28792 1d8531d126b10a1ed6bdec81179f9472 cfc2961a9495774f6b5c6c0400077d64cd98b7bb legit-20211020-git legit.asd
lense http://beta.quicklisp.org/archive/lense/2020-12-20/lense-20201220-git.tgz 4689 c0e59beeca17eecb58c99218ede96c62 eb6bc6b13ed2d399626508eeffc376bcfd183019 lense-20201220-git lense.asd
let-over-lambda http://beta.quicklisp.org/archive/let-over-lambda/2022-03-31/let-over-lambda-20220331-git.tgz 9464 055c752b42089fa73c47d8de313b6c6c 61bc5e740d7ec54042d14361da1cc76b24412591 let-over-lambda-20220331-git let-over-lambda-test.asd let-over-lambda.asd
let-plus http://beta.quicklisp.org/archive/let-plus/2019-11-30/let-plus-20191130-git.tgz 11247 1b8d1660ed67852ea31cad44a6fc15d0 e5ff604e4809908974fafaaf2af49e2cc0f8bcca let-plus-20191130-git let-plus.asd
letrec http://beta.quicklisp.org/archive/letrec/2019-03-07/letrec-20190307-hg.tgz 1899 68eed8ac600a1c2f157a3f6921efdfec ad8fb4a17a629ca025b5d6a8fda50ec84f5c8a8e letrec-20190307-hg letrec.asd
lev http://beta.quicklisp.org/archive/lev/2015-05-05/lev-20150505-git.tgz 9520 10f340f7500beb98b5c0d4a9876131fb e01073c528dbdfdaae90486095172dffc2c5c748 lev-20150505-git lev.asd
leveldb http://beta.quicklisp.org/archive/leveldb/2016-05-31/leveldb-20160531-git.tgz 6169 fa515cf6ba4109ee89db4c23039bff7b 0dc56929759d6562246601b782dc6fd6c1dbadb1 leveldb-20160531-git leveldb.asd
levenshtein http://beta.quicklisp.org/archive/levenshtein/2010-10-06/levenshtein-1.0.tgz 761 6266196d57f78c0dc894af44ecb9d223 bd6dc7c06dcde4ed721d0513cab44ffde6568bea levenshtein-1.0 levenshtein.asd
lfarm http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz 41956 4cc91df44a932b3175a1eabf73d6e42d d0020b44060e11ef149b366645d915fb1cecff06 lfarm-20150608-git lfarm-admin.asd lfarm-client.asd lfarm-common.asd lfarm-gss.asd lfarm-launcher.asd lfarm-server.asd lfarm-ssl.asd lfarm-test.asd
lhstats http://beta.quicklisp.org/archive/lhstats/2012-01-07/lhstats-20120107-git.tgz 42573 828738a13c638d9d090439e57aaaf0ef 655b38385e0cb69d344e58c1dd7331a7f314a0af lhstats-20120107-git lhstats.asd
liblmdb http://beta.quicklisp.org/archive/liblmdb/2017-08-30/liblmdb-20170830-git.tgz 4501 32fbfb193f327493ade3440f5bf9e989 2a355ed6a5a753f2a59c6584979056b5e5dc9bde liblmdb-20170830-git liblmdb.asd
lichat-ldap http://beta.quicklisp.org/archive/lichat-ldap/2019-07-10/lichat-ldap-20190710-git.tgz 3001 6ab1394eaf6d55b04d40e5d229b30a51 811b669faaec5248b59e91f74d85f3aa21aab9b5 lichat-ldap-20190710-git lichat-ldap.asd
lichat-protocol http://beta.quicklisp.org/archive/lichat-protocol/2022-07-07/lichat-protocol-20220707-git.tgz 56969 aec17f5e626f2f412b45cbbda5ec6d4a df20514237279abd03c6dff93abbabca18c9ae18 lichat-protocol-20220707-git lichat-protocol.asd
lichat-serverlib http://beta.quicklisp.org/archive/lichat-serverlib/2022-02-20/lichat-serverlib-20220220-git.tgz 15954 dc838bf57228e9e5ebdabad7d417a76f f045fced85634a3811d70063f1e4ba38090b629d lichat-serverlib-20220220-git lichat-serverlib.asd
lichat-tcp-client http://beta.quicklisp.org/archive/lichat-tcp-client/2022-07-07/lichat-tcp-client-20220707-git.tgz 8108 42a4155e5908c46170e76f342a72c446 5302db2eab1fa5d11484fe01a8ebff722eb38956 lichat-tcp-client-20220707-git lichat-tcp-client.asd
lichat-tcp-server http://beta.quicklisp.org/archive/lichat-tcp-server/2022-02-20/lichat-tcp-server-20220220-git.tgz 7681 2bb3a348984c117248373d256035627e 600bfc5187f746c10186b71334f3ccc8362402b8 lichat-tcp-server-20220220-git lichat-tcp-server.asd
lichat-ws-server http://beta.quicklisp.org/archive/lichat-ws-server/2022-02-20/lichat-ws-server-20220220-git.tgz 7055 ebf3a980ef74ca635a592de32da608b0 98c9543e7f4226577adb95c65de243629976026b lichat-ws-server-20220220-git lichat-ws-server.asd
lift http://beta.quicklisp.org/archive/lift/2022-11-06/lift-20221106-git.tgz 1131985 0cb449f861a1763d64dcf308e32f17cd 41e272bcde19e794f68deda07f816ee770b9014e lift-20221106-git lift-documentation.asd lift-test.asd lift.asd
lila http://beta.quicklisp.org/archive/lila/2019-10-07/lila-20191007-git.tgz 18320 d6b601d97d413abf9f401d5e6c5a0b48 2a13279fa64442360d5b88c2a2bbfda2addb8b3f lila-20191007-git lila.asd
lime http://beta.quicklisp.org/archive/lime/2015-12-18/lime-20151218-git.tgz 14590 1c43d6c9dbd8db49e0e25234477775d1 c60882af85f65f2e0e6cd4bea80112d862848c94 lime-20151218-git lime-example.asd lime-test.asd lime.asd
linear-programming http://beta.quicklisp.org/archive/linear-programming/2022-11-06/linear-programming-20221106-git.tgz 31923 36f6270cda931a5744599bd22b4a26e0 90b1bcae60ee689b16d665f56470c10a15983dc1 linear-programming-20221106-git linear-programming-test.asd linear-programming.asd
linear-programming-glpk http://beta.quicklisp.org/archive/linear-programming-glpk/2022-11-06/linear-programming-glpk-20221106-git.tgz 21796 863651167d29a8d0d26439c0eb220ded af82c0f36efcea44ac22e137ce9263c59b928d2a linear-programming-glpk-20221106-git linear-programming-glpk.asd
linedit http://beta.quicklisp.org/archive/linedit/2018-04-30/linedit-20180430-git.tgz 21140 a9f679411d01ec162eb1ba7c76e25d7a 82f1fab330a425fe3406a8a8a707575590cecf9f linedit-20180430-git linedit.asd
lineva http://beta.quicklisp.org/archive/lineva/2022-11-06/lineva-20221106-git.tgz 22712 dc953d6fbbcbb461bf7c1fbd8966656d 2d7a79aaaae63fc50e5d2664d4956bd1629cf1ae lineva-20221106-git lineva.asd
linewise-template http://beta.quicklisp.org/archive/linewise-template/2016-02-08/linewise-template-20160208-git.tgz 14893 396034dd6aab87bfe5db95b0064187b2 1cbddfa14e8620ad6eb87b8041bd5d3bf44abd4d linewise-template-20160208-git linewise-template.asd
linux-packaging http://beta.quicklisp.org/archive/linux-packaging/2021-10-20/linux-packaging-20211020-git.tgz 6936 58473ac4ed7eb21cf894d0c67b2ecf09 4ccd2d975a579e0a4a344c44f80aecdc0192611d linux-packaging-20211020-git linux-packaging-tests.asd linux-packaging.asd
lionchat http://beta.quicklisp.org/archive/lionchat/2022-02-20/lionchat-20220220-git.tgz 313318 c0d4c9729b3ce3d9ec59e575bfdaaf29 33ea49da6ad0ef78fb45aa77a646d62f59278f31 lionchat-20220220-git lionchat.asd
lisa http://beta.quicklisp.org/archive/lisa/2012-04-07/lisa-20120407-git.tgz 165079 6d999f92e2d894a7c4785b044955a49f b8b3350d837c7ea807163213dece93d59db0c725 lisa-20120407-git lisa.asd
lisp-binary http://beta.quicklisp.org/archive/lisp-binary/2022-11-06/lisp-binary-20221106-git.tgz 932834 331abb6341f170521793374810bf5c1d 5b01f3d0d5909a8bb82b62e2e9dec708dd7eb528 lisp-binary-20221106-git lisp-binary.asd test/lisp-binary-test.asd
lisp-chat http://beta.quicklisp.org/archive/lisp-chat/2021-02-28/lisp-chat-20210228-git.tgz 98989 32284bba3f0fa50df28fd0221e284320 c03d99063ad853e8975dade8855bd47bf2b0d747 lisp-chat-20210228-git lisp-chat.asd
lisp-critic http://beta.quicklisp.org/archive/lisp-critic/2022-11-06/lisp-critic-20221106-git.tgz 21111 86662679a3f3d803b221b515923e9c2c cef716fad91c9ab5917bf9439079a005e8566ad0 lisp-critic-20221106-git ckr-tables.asd lisp-critic.asd
lisp-executable http://beta.quicklisp.org/archive/lisp-executable/2018-08-31/lisp-executable-20180831-git.tgz 23139 63ea5e1673e9b2d90df1a2bbe10fd7b5 ec9d633c4ac367fa2f756e9960a83eb3805d3f71 lisp-executable-20180831-git lisp-executable-example.asd lisp-executable-tests.asd lisp-executable.asd
lisp-gflags http://beta.quicklisp.org/archive/lisp-gflags/2020-12-20/lisp-gflags-20201220-git.tgz 8244 593818f00cd4505eefbf7190b06640cc 054afc338359523a7b6842fb82e3c20db2d4721e lisp-gflags-20201220-git com.google.flag.asd
lisp-interface-library http://beta.quicklisp.org/archive/lisp-interface-library/2021-12-30/lisp-interface-library-20211230-git.tgz 61132 ba5195a32af6cd5cc4e4b57c9ebc924f e695c2d9e57f1770e5cb6acceb5da9505d29e90a lisp-interface-library-20211230-git lil.asd lisp-interface-library.asd
lisp-invocation http://beta.quicklisp.org/archive/lisp-invocation/2018-02-28/lisp-invocation-20180228-git.tgz 10863 3ed327ad1fc47f27cc1332d9a8b7e20e 49234e20c19ecb65fa0d743684c92965e8978160 lisp-invocation-20180228-git lisp-invocation.asd
lisp-namespace http://beta.quicklisp.org/archive/lisp-namespace/2022-11-06/lisp-namespace-20221106-git.tgz 9786 cd8e7c45781e579ae534b5704cd4de6c 6b4061f20c59281e1b508f0b268e53c799b04cb8 lisp-namespace-20221106-git lisp-namespace.asd lisp-namespace.test.asd
lisp-preprocessor http://beta.quicklisp.org/archive/lisp-preprocessor/2020-07-15/lisp-preprocessor-20200715-git.tgz 5181 5e763b408436f94ce10fca3eaf5bd26a 6d594f92bb06366aa03c6e7d2251a9b2977918f8 lisp-preprocessor-20200715-git lisp-preprocessor.asd
lisp-stat http://beta.quicklisp.org/archive/lisp-stat/2022-11-06/lisp-stat-20221106-git.tgz 238213 3e1e343c219c3878f42f02b1670b4fec d848f5afcae52b2c64a5ab9dbf19137cbf178c58 lisp-stat-20221106-git lisp-stat.asd
lisp-unit http://beta.quicklisp.org/archive/lisp-unit/2017-01-24/lisp-unit-20170124-git.tgz 18163 2c55342cb8af18b290bb6a28c75deac5 234203b4f9903cd82b1698f3a90439fb2bbc3f7e lisp-unit-20170124-git lisp-unit.asd
lisp-unit2 http://beta.quicklisp.org/archive/lisp-unit2/2022-11-06/lisp-unit2-20221106-git.tgz 34369 62b2c7c011d26e897cc7db11c9f29b9b 591ae8d03038830c1dd21d3749ebb7dc9f246eb1 lisp-unit2-20221106-git lisp-unit2.asd
lisp-zmq http://beta.quicklisp.org/archive/lisp-zmq/2020-02-18/lisp-zmq-20200218-git.tgz 15423 fdae33782f1a6ebd00de467164dcbaed 0bbe3ca1992d63dbf7f00dd6611aeb6a7b29118e lisp-zmq-20200218-git zmq-examples.asd zmq-test.asd zmq.asd
lispbuilder http://beta.quicklisp.org/archive/lispbuilder/2021-08-07/lispbuilder-20210807-git.tgz 7549861 54361f330a8daa23f55d84e29eb9e213 1d295c4fad1a43195f9ee625fff0bc4b99c1058e lispbuilder-20210807-git lispbuilder-lexer/lispbuilder-lexer.asd lispbuilder-net/lispbuilder-net-cffi.asd lispbuilder-net/lispbuilder-net.asd lispbuilder-opengl/lispbuilder-opengl-1-1.asd lispbuilder-opengl/lispbuilder-opengl-examples.asd lispbuilder-regex/lispbuilder-regex.asd lispbuilder-sdl-gfx/lispbuilder-sdl-gfx-binaries.asd lispbuilder-sdl-gfx/lispbuilder-sdl-gfx-cffi.asd lispbuilder-sdl-gfx/lispbuilder-sdl-gfx-examples.asd lispbuilder-sdl-gfx/lispbuilder-sdl-gfx.asd lispbuilder-sdl-image/lispbuilder-sdl-image-binaries.asd lispbuilder-sdl-image/lispbuilder-sdl-image-cffi.asd lispbuilder-sdl-image/lispbuilder-sdl-image-examples.asd lispbuilder-sdl-image/lispbuilder-sdl-image.asd lispbuilder-sdl-mixer/lispbuilder-sdl-mixer-binaries.asd lispbuilder-sdl-mixer/lispbuilder-sdl-mixer-cffi.asd lispbuilder-sdl-mixer/lispbuilder-sdl-mixer-examples.asd lispbuilder-sdl-mixer/lispbuilder-sdl-mixer.asd lispbuilder-sdl-ttf/lispbuilder-sdl-ttf-binaries.asd lispbuilder-sdl-ttf/lispbuilder-sdl-ttf-cffi.asd lispbuilder-sdl-ttf/lispbuilder-sdl-ttf-examples.asd lispbuilder-sdl-ttf/lispbuilder-sdl-ttf.asd lispbuilder-sdl/cocoahelper.asd lispbuilder-sdl/lispbuilder-sdl-assets.asd lispbuilder-sdl/lispbuilder-sdl-base.asd lispbuilder-sdl/lispbuilder-sdl-binaries.asd lispbuilder-sdl/lispbuilder-sdl-cffi.asd lispbuilder-sdl/lispbuilder-sdl-cl-vectors-examples.asd lispbuilder-sdl/lispbuilder-sdl-cl-vectors.asd lispbuilder-sdl/lispbuilder-sdl-examples.asd lispbuilder-sdl/lispbuilder-sdl-vecto-examples.asd lispbuilder-sdl/lispbuilder-sdl-vecto.asd lispbuilder-sdl/lispbuilder-sdl.asd lispbuilder-windows/lispbuilder-windows.asd lispbuilder-yacc/lispbuilder-yacc.asd
lispcord http://beta.quicklisp.org/archive/lispcord/2020-09-25/lispcord-20200925-git.tgz 27463 b3b4b60f2e788e5d9511f1701bca2375 0f666cbb07e74cb35c5666bd504ff4919694230f lispcord-20200925-git examples/example-bot/example-bot.asd lispcord.asd
lispqr http://beta.quicklisp.org/archive/lispqr/2021-06-30/lispqr-20210630-git.tgz 24993 b82f915d27d0a7c8f85aa6f7e359fc71 0b1da370a6c92a985ce56ca4556f14cbc5682050 lispqr-20210630-git lispqr.asd
list-named-class http://beta.quicklisp.org/archive/list-named-class/2020-03-25/list-named-class-20200325-git.tgz 5334 8f26a03d1bc97bcb2cf1af8c0640c2c5 af1ef6f420b466276b87ebf456290b5219db4a02 list-named-class-20200325-git list-named-class.asd
listoflist http://beta.quicklisp.org/archive/listoflist/2014-08-26/listoflist-20140826-git.tgz 12188 598138f6ddf5241eaa283d0adce7878d c4138b36e50717f3e826fbc0d77cd9c00d0c9612 listoflist-20140826-git listoflist.asd
listopia http://beta.quicklisp.org/archive/listopia/2021-04-11/listopia-20210411-git.tgz 10768 ebc6eead50c461528b3404e680da54cf 5fe15a3fd63876ec92125f23ff03fc3768f87eb4 listopia-20210411-git listopia-bench.asd listopia.asd
literate-lisp http://beta.quicklisp.org/archive/literate-lisp/2022-11-06/literate-lisp-20221106-git.tgz 115143 848b56b42e94c966b20a6c95063549c2 b03f6cfb6290effbcf9b181a3ab81a47f8481f6d literate-lisp-20221106-git literate-demo.asd literate-lisp.asd
litterae http://beta.quicklisp.org/archive/litterae/2020-07-15/litterae-20200715-git.tgz 19993 628d506e4a072df70508ebb1503529c2 9fa4dd608a0a20eb9d7f07694ede78801817a11a litterae-20200715-git litterae-test-system.asd litterae.asd
livesupport http://beta.quicklisp.org/archive/livesupport/2019-05-21/livesupport-release-quicklisp-71e6e412-git.tgz 2939 9eb376b26689ac54d2a51f5189587ec5 e2df3d1a994fad4f8149c2795dc5d7de5a10d5ce livesupport-release-quicklisp-71e6e412-git livesupport.asd
lla http://beta.quicklisp.org/archive/lla/2018-03-28/lla-20180328-git.tgz 38969 61d583603d5cacf9d81486a0cfcfaf6a 5c747b960f4ed782de3a11505eb02fef3b7b5d0a lla-20180328-git lla.asd
lmdb http://beta.quicklisp.org/archive/lmdb/2022-02-20/lmdb-20220220-git.tgz 91457 e4b5b90782b029e97adf35c6b8e89456 a03dfd9c21e2e1fff5682bb411439b2ae1efcc13 lmdb-20220220-git lmdb.asd
lml http://beta.quicklisp.org/archive/lml/2015-09-23/lml-20150923-git.tgz 16279 4250f2b2c4d110cc728645e8a1eba963 5e9d7018b7487783aeec69ff4ac283a56bccd1ef lml-20150923-git lml-tests.asd lml.asd
lml2 http://beta.quicklisp.org/archive/lml2/2015-09-23/lml2-20150923-git.tgz 31590 99d76c1971e4fceaa6496291c4ede90b b119542c292e0ff8ed86874cbe6ee64a6c16a9a0 lml2-20150923-git lml2-tests.asd lml2.asd
local-package-aliases http://beta.quicklisp.org/archive/local-package-aliases/2020-12-20/local-package-aliases-20201220-git.tgz 8439 953d9d5e8a35191698d57f33d4fc1dd7 a7ea98836f90f1b3c7c5e6379a828a38701351db local-package-aliases-20201220-git local-package-aliases.asd
local-time http://beta.quicklisp.org/archive/local-time/2022-07-07/local-time-20220707-git.tgz 779466 924251d13a8753ae07b2e7eebc382cc7 ad240bf0935d5ade47c6feb3f60c931f7feea3da local-time-20220707-git cl-postgres+local-time.asd local-time.asd
local-time-duration http://beta.quicklisp.org/archive/local-time-duration/2018-04-30/local-time-duration-20180430-git.tgz 10333 8ad2f86ea33d4c7b3014e2152632b88c 0b443efd31c990ad022e9c16576bf68b2359de0b local-time-duration-20180430-git cl-postgres+local-time-duration.asd local-time-duration.asd
log4cl http://beta.quicklisp.org/archive/log4cl/2021-12-09/log4cl-20211209-git.tgz 922123 569122fed30c089b67527926468dcf44 5e2817d6063de92a20e6f5d2dae2287e67c1b0d1 log4cl-20211209-git log4cl-examples.asd log4cl.asd log4cl.log4slime.asd log4cl.log4sly.asd
log4cl-extras http://beta.quicklisp.org/archive/log4cl-extras/2022-11-06/log4cl-extras-20221106-git.tgz 27984 e65d868b23eb89fdb37460902a0a367d 6254be3aa41ca4fe794f0c6b2047b5f5cac5a42b log4cl-extras-20221106-git log4cl-extras-test.asd log4cl-extras.asd
log5 http://beta.quicklisp.org/archive/log5/2011-06-19/log5-20110619-git.tgz 29106 b05a585fbf58b25367c05ec8bb814e8c 07d72b5327c5e8795eac99d235cc1a483a4cbafd log5-20110619-git log5.asd
lorem-ipsum http://beta.quicklisp.org/archive/lorem-ipsum/2018-10-18/lorem-ipsum-20181018-git.tgz 3756 4a89cae2f82951c8cf76348b5f0600ee 6216e403bb0c4da378eb6b16e094926355c13549 lorem-ipsum-20181018-git lorem-ipsum.asd
lowlight http://beta.quicklisp.org/archive/lowlight/2013-12-11/lowlight-20131211-git.tgz 17517 83b71610e5b7de0979ffc9dcff43e129 d90ad3e313ce9d51984519b5512fd892ab513f77 lowlight-20131211-git doc/lowlight.doc.asd lowlight.asd old/lowlight.old.asd tests/lowlight.tests.asd
lparallel http://beta.quicklisp.org/archive/lparallel/2016-08-25/lparallel-20160825-git.tgz 78551 6393e8d0c0cc9ed1c88b6e7cca8de5df 1514c95041efd503f335e2cd96ba5ef1537415cc lparallel-20160825-git lparallel-bench.asd lparallel-test.asd lparallel.asd
lquery http://beta.quicklisp.org/archive/lquery/2020-12-20/lquery-20201220-git.tgz 38666 a71685848959cf33cd6963b4a5f9e2ed 9ffafbe59d6488fad110339e51db5bc7cf048a62 lquery-20201220-git lquery-test.asd lquery.asd
lredis http://beta.quicklisp.org/archive/lredis/2014-11-06/lredis-20141106-git.tgz 8338 c3696a2d2665fd8c31002c3e9e22f6b6 49824a4b3d2730746a19c94536f68971cbb48ea1 lredis-20141106-git lredis.asd
lsx http://beta.quicklisp.org/archive/lsx/2022-02-20/lsx-20220220-git.tgz 7187 f61b8dd8cde6ffb66535698fea1d240f 99f4fad12677839467feb18662df2131fafcf8c1 lsx-20220220-git cl-syntax-lsx.asd lsx.asd
ltk http://beta.quicklisp.org/archive/ltk/2022-11-06/ltk-20221106-git.tgz 62697 36a84b05e25ed43f1efb048714c87a2a 4711cfc5e460fba40cb1713a0029255d7b524b7d ltk-20221106-git ltk/ltk-mw.asd ltk/ltk-remote.asd ltk/ltk.asd
luckless http://beta.quicklisp.org/archive/luckless/2022-11-06/luckless-20221106-git.tgz 21394 b2dc3801c1b2888da7f9f33c0654c59a 75837877a80bd674941f321c75d3c597edad9038 luckless-20221106-git luckless-test.asd luckless.asd
lunamech-matrix-api http://beta.quicklisp.org/archive/lunamech-matrix-api/2022-11-06/lunamech-matrix-api-20221106-git.tgz 53963 120370fcbe91dee82567149519a688e7 689914e239cdd34a8168e2166ff81969d737a1e8 lunamech-matrix-api-20221106-git lunamech-matrix-api.asd
lw-compat http://beta.quicklisp.org/archive/lw-compat/2016-03-18/lw-compat-20160318-git.tgz 2165 024b8e63d13fb12dbcccaf18cf4f8dfa 92259792af7830d80a868c5f06b2510ead325110 lw-compat-20160318-git lw-compat.asd
lyrics http://beta.quicklisp.org/archive/lyrics/2021-08-07/lyrics-20210807-git.tgz 4500 09c8efbb59e2894bcd7ad63a6a6c0526 94406adeb980bac71bdc80607b2faf47b9f68106 lyrics-20210807-git lyrics.asd
macro-html http://beta.quicklisp.org/archive/macro-html/2015-12-18/macro-html-20151218-git.tgz 18865 4c73847f830a8ccacd87e5ea76d44bb3 3b03c5253738adea7d0f7b8a67617356a293c7cc macro-html-20151218-git macro-html.asd
macro-level http://beta.quicklisp.org/archive/macro-level/2012-10-13/macro-level-1.0.1.tgz 1907 486ad598536a7b719f04c0f756d9017f 355a1254441193c1698f2641e84f3dfc356f8591 macro-level-1.0.1 macro-level.asd
macrodynamics http://beta.quicklisp.org/archive/macrodynamics/2018-02-28/macrodynamics-20180228-git.tgz 7668 8f226b02f6442d439edc80da09bd8a72 dcffeeebbb8b5084fd1517cab04abb515fb9a4a6 macrodynamics-20180228-git macrodynamics.asd
macroexpand-dammit http://beta.quicklisp.org/archive/macroexpand-dammit/2013-11-11/macroexpand-dammit-20131111-http.tgz 3604 6290fa304f986ea05e084c6342dd0c0f e0b77f879b8fd5a85120cae0b2a90ae17c93fc9d macroexpand-dammit-20131111-http macroexpand-dammit.asd
madeira-port http://beta.quicklisp.org/archive/madeira-port/2015-07-09/madeira-port-20150709-git.tgz 4844 f3d5a6aea61ecb83c56fb123d6a1ecf8 841f3bac6df3588220adc49c5caccaf495800c03 madeira-port-20150709-git madeira-port.asd
magic-ed http://beta.quicklisp.org/archive/magic-ed/2020-03-25/magic-ed-20200325-git.tgz 4442 b790a6a7f06c97ef1586b8e223cb8a63 f50ce6a7c280684bb8b5fba89409500eba2debb3 magic-ed-20200325-git magic-ed.asd
magicffi http://beta.quicklisp.org/archive/magicffi/2021-05-31/magicffi-20210531-git.tgz 11901 f5494194b62a16cbd43929ca27641837 21c5aaa1843262429ac47cfebff86a19c8feb62d magicffi-20210531-git magicffi.asd
magicl http://beta.quicklisp.org/archive/magicl/2021-04-11/magicl-v0.9.1.tgz 544160 5b28a64d6577cc9b97b7719a82ae4d1c c5c74e57e8d39d6eb222ec9507a81bc11f87f4bd magicl-v0.9.1 magicl-examples.asd magicl-gen.asd magicl-tests.asd magicl-transcendental.asd magicl.asd
maiden http://beta.quicklisp.org/archive/maiden/2022-07-07/maiden-20220707-git.tgz 238991 3b55e7c8bab53d4deb8875bafa09c837 9ca4bde8962132c1bb27e73c02871f3c248ec094 maiden-20220707-git agents/accounts/maiden-accounts.asd agents/activatable/maiden-activatable.asd agents/blocker/maiden-blocker.asd agents/chatlog/maiden-chatlog.asd agents/commands/maiden-commands.asd agents/core-manager/maiden-core-manager.asd agents/counter/maiden-counter.asd agents/crimes/maiden-crimes.asd agents/dictionary/maiden-dictionary.asd agents/emoticon/maiden-emoticon.asd agents/help/maiden-help.asd agents/lastfm/maiden-lastfm.asd agents/location/maiden-location.asd agents/lookup/maiden-lookup.asd agents/markov/maiden-markov.asd agents/medals/maiden-medals.asd agents/notify/maiden-notify.asd agents/permissions/maiden-permissions.asd agents/relay/maiden-channel-relay.asd agents/silly/maiden-silly.asd agents/talk/maiden-talk.asd agents/throttle/maiden-throttle.asd agents/time/maiden-time.asd agents/trivia/maiden-trivia.asd agents/urlinfo/maiden-urlinfo.asd agents/vote/maiden-vote.asd agents/weather/maiden-weather.asd clients/irc/maiden-irc.asd clients/lichat/maiden-lichat.asd clients/relay/maiden-relay.asd clients/twitter/maiden-twitter.asd maiden.asd modules/api-access/maiden-api-access.asd modules/client-entities/maiden-client-entities.asd modules/networking/maiden-networking.asd modules/serialize/maiden-serialize.asd modules/storage/maiden-storage.asd
maidenhead http://beta.quicklisp.org/archive/maidenhead/2022-03-31/maidenhead-20220331-git.tgz 14634 bc220da3787155a5b5a8439aa10a9478 f82e77aa1ee9032d8e8f4a8c7a510fcaeef1c0e0 maidenhead-20220331-git maidenhead.asd
mailbox http://beta.quicklisp.org/archive/mailbox/2013-10-03/mailbox-20131003-git.tgz 1907 fd52c2dc8d80c87013a6418b04c4c737 ee9f30c005b768a945c98fc466ec276a662b2b0b mailbox-20131003-git mailbox.asd
mailgun http://beta.quicklisp.org/archive/mailgun/2022-07-07/mailgun-20220707-git.tgz 10638 06085fc09b4dbd33ac3d318f9f8b98ac b1b87b8d4367a7579f1b1dc31ab037088dbe1d5b mailgun-20220707-git mailgun.asd
make-hash http://beta.quicklisp.org/archive/make-hash/2013-06-15/make-hash-20130615-git.tgz 361160 4f612ef068411284c88e0381fa4a0c7f a0f2260867e32967ef02f316b8d42d9d168c140f make-hash-20130615-git make-hash-tests.asd make-hash.asd
manifest http://beta.quicklisp.org/archive/manifest/2012-02-08/manifest-20120208-git.tgz 98532 16b500a79f0cd4a8f95760cb634cd617 13441aaf0b11a1275a8f72d0ec31908f60307556 manifest-20120208-git manifest.asd
map-bind http://beta.quicklisp.org/archive/map-bind/2012-08-11/map-bind-20120811-git.tgz 2092 a24c5c012e41b87f836b6d8ef318e7cd 047b3ccf3f9d433eb2104bd9da89de7f8e81a2a4 map-bind-20120811-git map-bind.asd
map-set http://beta.quicklisp.org/archive/map-set/2019-03-07/map-set-20190307-hg.tgz 2389 866dba36cdf060c943267cb79ccc0532 9b7c74de8b801583539807e28c676c5ed630bec3 map-set-20190307-hg map-set.asd
marching-cubes http://beta.quicklisp.org/archive/marching-cubes/2015-07-09/marching-cubes-20150709-git.tgz 97306 a44282b741e9dc43d40cb1979a6c7afe b8002c6a01dc8579d3f109c6ecd36dce88e9075f marching-cubes-20150709-git marching-cubes-example.asd marching-cubes-test.asd marching-cubes.asd
markdown.cl http://beta.quicklisp.org/archive/markdown.cl/2021-02-28/markdown.cl-20210228-git.tgz 21601 736db40fedbee2945ffccd8ef7dcb38e 89c6ff147d53ef6d42d4c7ccd3fe35adae929254 markdown.cl-20210228-git markdown.cl-test.asd markdown.cl.asd
markup http://beta.quicklisp.org/archive/markup/2022-11-06/markup-20221106-git.tgz 22704 2bf5d55a90685ef769bc17e8d78ba405 7b42f107ad8e2ee784ab13456a56f17a105502db markup-20221106-git markup.asd markup.test.asd
marshal http://beta.quicklisp.org/archive/marshal/2013-07-20/marshal-20130720-git.tgz 2921 7b2f8d0cb6c95f2418eca133a2e299b6 2c3d9e2c3b04cb581eb8f1f0dc94055176328029 marshal-20130720-git fmarshal-test.asd fmarshal.asd
math http://beta.quicklisp.org/archive/math/2022-11-06/math-20221106-git.tgz 74619 715e158c04703629ab1f955bf43049bd a80c018271c15259108dd64612f53642815c78e5 math-20221106-git math.asd
mathkit http://beta.quicklisp.org/archive/mathkit/2016-02-08/mathkit-20160208-git.tgz 5451 f00124bdf2eea4d18154a4497bf414f7 f5323f595ca08be75b394d1baa82380982dd2f4e mathkit-20160208-git mathkit.asd
matrix-case http://beta.quicklisp.org/archive/matrix-case/2021-10-20/matrix-case-20211020-git.tgz 4304 ac6adce8a99471866ef536ad73d425ea cae3c9b826f389fb1c77679977d386bb07af4781 matrix-case-20211020-git matrix-case.asd spec/matrix-case.test.asd
maxpc http://beta.quicklisp.org/archive/maxpc/2020-04-27/maxpc-20200427-git.tgz 25931 a40e8372eb4ad2bcd1fc1c6948e57df3 f77e66ade543c01db1c45a5430f13017fa8b3412 maxpc-20200427-git maxpc-test.asd maxpc.asd
mbe http://beta.quicklisp.org/archive/mbe/2020-02-18/mbe-20200218-git.tgz 14018 1d1a1c3541e231d74ba16e8b0bde550b 2b0511e666656123c208df72681110de3c93d9c5 mbe-20200218-git mbe.asd
mcase http://beta.quicklisp.org/archive/mcase/2021-10-20/mcase-20211020-git.tgz 2747 39f3a7bd07d2676ced4752062fb717e9 7dc0b3b9a0891dc9846bba9dc172896877410962 mcase-20211020-git mcase.asd spec/mcase.test.asd
mcclim http://beta.quicklisp.org/archive/mcclim/2022-11-06/mcclim-20221106-git.tgz 2387651 a258f4c1bf9dab33add4546d53e1ccf6 1ffd4257574420c1e43cfaa2fe27af845015c778 mcclim-20221106-git Apps/Clouseau/clouseau.asd Apps/Debugger/clim-debugger.asd Apps/Functional-Geometry/functional-geometry.asd Apps/Listener/clim-listener.asd Apps/Scigraph/scigraph.asd Backends/CLX-fb/mcclim-clx-fb.asd Backends/CLX/mcclim-clx.asd Backends/Null/mcclim-null.asd Backends/PDF/clim-pdf.asd Backends/PostScript/clim-postscript-font.asd Backends/PostScript/clim-postscript.asd Backends/RasterImage/mcclim-raster-image.asd Backends/SVG/mcclim-svg.asd Backends/common/mcclim-backend-common.asd Core/clim-core.asd Core/clim.asd Examples/clim-examples.asd Experimental/tree-with-cross-edges/mcclim-tree-with-cross-edges.asd Extensions/Franz/mcclim-franz.asd Extensions/bezier/mcclim-bezier.asd Extensions/bitmap-formats/mcclim-bitmaps.asd Extensions/conditional-commands/conditional-commands.asd Extensions/fontconfig/mcclim-fontconfig.asd Extensions/fonts/mcclim-fonts.asd Extensions/harfbuzz/mcclim-harfbuzz.asd Extensions/layouts/mcclim-layouts.asd Extensions/render/mcclim-render.asd Extensions/tooltips/mcclim-tooltips.asd Libraries/Drei/Persistent/persistent.asd Libraries/Drei/cl-automaton/automaton.asd Libraries/Drei/drei-mcclim.asd Libraries/ESA/esa-mcclim.asd Libraries/Slim/slim.asd clim-lisp.asd mcclim.asd
md5 http://beta.quicklisp.org/archive/md5/2021-06-30/md5-20210630-git.tgz 16719 ecb1fa8eea6848c2f14fdfeb03d47056 f907b28a9a3d1ce16651dcf7245dedeed129acbb md5-20210630-git md5.asd
media-types http://beta.quicklisp.org/archive/media-types/2022-03-31/media-types-20220331-git.tgz 20739 bb9260ef382914525d4129442a65a50c 87a13478d7b05dff1bd17ff2d769585408045f78 media-types-20220331-git media-types.asd
mel-base http://beta.quicklisp.org/archive/mel-base/2018-02-28/mel-base-20180228-git.tgz 67969 17931e0cbfec8fafb7b825a0af0c897d 447445ec593bc3191d06233e505c9a55247f8be0 mel-base-20180228-git mel-base.asd
memoize http://beta.quicklisp.org/archive/memoize/2014-08-26/memoize-20140826-http.tgz 3547 bdf9cf51fb95293e42553045b7faea2f 1c29c09b7f60686ac929688b842db4c6bcb8f021 memoize-20140826-http memoize.asd
message-oo http://beta.quicklisp.org/archive/message-oo/2013-06-15/message-oo-20130615-git.tgz 2426 44631ce806432e2a55fdfdca7de414ac 95d35b35cfb93d1a19760a6291e5f756e05be25e message-oo-20130615-git message-oo.asd
messagebox http://beta.quicklisp.org/archive/messagebox/2021-10-20/messagebox-20211020-git.tgz 6795 b7a5bbe50de33075a9cf67039614e460 93a5f754c1c8492eaca8099c71e9836e71e431d3 messagebox-20211020-git messagebox.asd
meta http://beta.quicklisp.org/archive/meta/2015-06-08/meta-20150608-git.tgz 3371 3322d6d54783269122e087b1349e3171 1dfa5cc33d7d1840bfc0d5626758e3bce3e57914 meta-20150608-git meta.asd
meta-sexp http://beta.quicklisp.org/archive/meta-sexp/2020-10-16/meta-sexp-20201016-git.tgz 8562 7972ec9d0cad5afe6085e34da9e5394e cb25d50abf0297e4be6986a59a2910c1c4883d43 meta-sexp-20201016-git meta-sexp.asd
metabang-bind http://beta.quicklisp.org/archive/metabang-bind/2020-02-18/metabang-bind-20200218-git.tgz 22543 25ee72526862a9d794f7b0fc1826029e 7e8c59e23d3451cfe4623699002e12f6b079e918 metabang-bind-20200218-git metabang-bind-test.asd metabang-bind.asd
metacopy http://beta.quicklisp.org/archive/metacopy/2017-04-03/metacopy-20170403-darcs.tgz 9186 caa5ac0a1f5e3741e7f789589ff537fe 559f0201e9fe8708b9211ef856ed35eefd0167f9 metacopy-20170403-darcs metacopy-with-contextl.asd metacopy.asd
metalock http://beta.quicklisp.org/archive/metalock/2020-09-25/metalock-20200925-git.tgz 2654 829164a633847affb9b4515197ca6198 3a9252501d37b168c68e5ec753b608e7aee377d8 metalock-20200925-git metalock.asd
metap http://beta.quicklisp.org/archive/metap/2015-05-05/metap-20150505-git.tgz 3176 1de5d80b35b75fa3c8f668adb2fb891e bc6cb669fe93462ad434fd620eeeac1b17b59aa5 metap-20150505-git metap-test.asd metap.asd
metatilities http://beta.quicklisp.org/archive/metatilities/2018-02-28/metatilities-20180228-git.tgz 194405 bb75a7979528d08ec9c27ee154b9317e 531048725a416caea22d5996edd570f7cd25947a metatilities-20180228-git metatilities-test.asd metatilities.asd
metatilities-base http://beta.quicklisp.org/archive/metatilities-base/2019-12-27/metatilities-base-20191227-git.tgz 70648 7968829ca353c4a42784a151317029f1 e2abddb20c1a29455fc761c4c7716d9fdbebf0e9 metatilities-base-20191227-git metatilities-base-test.asd metatilities-base.asd
metering http://beta.quicklisp.org/archive/metering/2020-02-18/metering-20200218-git.tgz 17062 602fe742106ad19bfb331c2a97fbd811 dc01e5ecd706f54aabd580d36577648260f17f24 metering-20200218-git metering.asd
method-combination-utilities http://beta.quicklisp.org/archive/method-combination-utilities/2014-11-06/method-combination-utilities-20141106-git.tgz 7311 881048d7bed117b8d7b4547a5111812d cb5a6ab010f6981e27c83f2ba22d33649a4db46a method-combination-utilities-20141106-git method-combination-utilities.asd
method-hooks http://beta.quicklisp.org/archive/method-hooks/2020-09-25/method-hooks-20200925-git.tgz 14360 4fad17e5482de27554abc24eed285666 acb7bf29a84865152b7b533456d87909ea22ae40 method-hooks-20200925-git method-hooks-test.asd method-hooks.asd
method-versions http://beta.quicklisp.org/archive/method-versions/2011-05-22/method-versions_0.1.2011.05.18.tgz 4709 3e64215eeae18b8c830653e4ca22fe26 96476b31ff0c747c58477b2dc6227e1bfff611c8 method-versions_0.1.2011.05.18 method-versions.asd
mexpr http://beta.quicklisp.org/archive/mexpr/2015-07-09/mexpr-20150709-git.tgz 5385 7660c46156c0f98adc208451f64ff62f 9f9be5508184cc8dd23ed2e04812e1b71fdd1b5e mexpr-20150709-git mexpr-tests.asd mexpr.asd
mfiano-utils http://beta.quicklisp.org/archive/mfiano-utils/2022-07-07/mfiano-utils-20220707-git.tgz 9902 7bb3eb242a0118e82295b62bd9bf2c2a 3ae9b3af61f3ee197a723a67ebf9a1ef813d3004 mfiano-utils-20220707-git mfiano-utils.asd
mgl http://beta.quicklisp.org/archive/mgl/2022-02-20/mgl-20220220-git.tgz 809282 0d23508761ebb6ce1661c04fb09141d3 671f22917b8b7253de38560bd7b459c1aabd2ee5 mgl-20220220-git gnuplot/mgl-gnuplot.asd mgl-example.asd mgl.asd
mgl-mat http://beta.quicklisp.org/archive/mgl-mat/2022-02-20/mgl-mat-20220220-git.tgz 117517 9bdf17502d22cc3b48dbea18efd9d386 679fb87aac0def6c4d1ac9cc304691aafe2a8abb mgl-mat-20220220-git mgl-mat.asd
mgl-pax http://beta.quicklisp.org/archive/mgl-pax/2022-03-31/mgl-pax-20220331-git.tgz 250427 26382cee0a8623e02f45afcb16ec1f1f 053c0707f82c6f5b98468575d7d03bbe4e5a6a06 mgl-pax-20220331-git mgl-pax.asd mgl-pax.asdf.asd
mgrs http://beta.quicklisp.org/archive/mgrs/2022-03-31/mgrs-20220331-git.tgz 16602 95ab791dfeeede7e7ebc806b21851909 6c8d2e6a8de1ef6ae99a258fec1cadc53ee947ca mgrs-20220331-git mgrs.asd
micmac http://beta.quicklisp.org/archive/micmac/2022-02-20/micmac-20220220-git.tgz 23645 e9fe025ecc57e55d3e34a4ac19b22859 d249f4eda9a406d690d10b031bdc03d6b5d0f11b micmac-20220220-git micmac.asd
midi http://beta.quicklisp.org/archive/midi/2010-10-06/midi-20070618.tgz 6886 78d494c8d2fbc9a6af1b2d3e1b3c25d7 73a273cd33bccfa2bcd8ff93b38de5b1523e9993 midi-20070618 midi.asd
millet http://beta.quicklisp.org/archive/millet/2021-12-09/millet-20211209-git.tgz 9564 ffad6f6b9b6846e6f26cc2905523b070 825dfb17f203096b2a1e697df44be0dfb5548bed millet-20211209-git millet.asd spec/millet.test.asd
minheap http://beta.quicklisp.org/archive/minheap/2016-06-28/minheap-20160628-git.tgz 17015 27a57cdd27e91eb767f1377fcbfe2af3 0fe362afcf54c58c43ac9c36d8384d0be4782e02 minheap-20160628-git minheap-tests.asd minheap.asd
mini-cas http://beta.quicklisp.org/archive/mini-cas/2015-09-23/mini-cas-20150923-git.tgz 7018 5b29524320ea446c59ee913d6787faf0 7361170e6ebafe271aaf8b32962214bb2e860b5f mini-cas-20150923-git mini-cas.asd
minilem http://beta.quicklisp.org/archive/minilem/2020-02-18/minilem-20200218-git.tgz 421541 b77bd135381061eb7482525e0bffd60d 8fbc4519ec6fc5e1c8059cb867d9e6e1ec7530d7 minilem-20200218-git minilem.asd
misc-extensions http://beta.quicklisp.org/archive/misc-extensions/2015-06-08/misc-extensions-20150608-git.tgz 25456 ef8a05dd4382bb9d1e3960aeb77e332e 3f22977672a040f72b46d49fa680757deeff6a12 misc-extensions-20150608-git misc-extensions.asd
mito http://beta.quicklisp.org/archive/mito/2022-11-06/mito-20221106-git.tgz 42514 7d3a7c7ad051bf9e766c8556c321ca9b 7a47b03d3ac922c4ff508928d03585d5ab74a555 mito-20221106-git lack-middleware-mito.asd mito-core.asd mito-migration.asd mito-test.asd mito.asd
mito-auth http://beta.quicklisp.org/archive/mito-auth/2017-10-19/mito-auth-20171019-git.tgz 2014 f2ef144e4012a1ecac9420a64ac6ab16 f5c7ed9c9a43f739d1afddfb3616322b58b33746 mito-auth-20171019-git mito-auth.asd
mixalot http://beta.quicklisp.org/archive/mixalot/2015-12-18/mixalot-20151218-git.tgz 49886 c2132e94690a03a39343fff3a12cff1f 22856864b7a35fb44f52547cc6387e31f4db42e1 mixalot-20151218-git flac.asd mixalot-flac.asd mixalot-mp3.asd mixalot-vorbis.asd mixalot.asd mpg123-ffi.asd vorbisfile-ffi.asd
mk-defsystem http://beta.quicklisp.org/archive/mk-defsystem/2022-02-20/mk-defsystem-20220220-git.tgz 77911 16cb2c2e5e384c58dbaada2edb0007c0 84dfe532d6b1930e189e40237d6e3ff98d7651af mk-defsystem-20220220-git mk-defsystem.asd
mk-string-metrics http://beta.quicklisp.org/archive/mk-string-metrics/2018-01-31/mk-string-metrics-20180131-git.tgz 5395 40f23794a7d841cb178f5951d3992886 e869de7baf6a85580ae92dd30e2ddffd9ce35400 mk-string-metrics-20180131-git mk-string-metrics-tests.asd mk-string-metrics.asd
mmap http://beta.quicklisp.org/archive/mmap/2022-07-07/mmap-20220707-git.tgz 13359 8898fca2e895cb1aa3d9d954ed6ff391 4a4401c87d7ad307f9a912f33f4bc2c7088023b7 mmap-20220707-git mmap-test.asd mmap.asd
mnas-graph http://beta.quicklisp.org/archive/mnas-graph/2022-11-06/mnas-graph-20221106-git.tgz 44352 c57a9d37df88cc88cee574a62cbaf05c 082f9be890825b710e3d645be16997da24b1d8cb mnas-graph-20221106-git mnas-graph.asd
mnas-hash-table http://beta.quicklisp.org/archive/mnas-hash-table/2022-07-07/mnas-hash-table-20220707-git.tgz 16916 d36737d8b5357b1e7fce9794d9a1ed68 9f62d4844e7bdd02495882ed33742c005cda877b mnas-hash-table-20220707-git mnas-hash-table.asd
mnas-package http://beta.quicklisp.org/archive/mnas-package/2022-11-06/mnas-package-20221106-git.tgz 41336 2d57e94e2efadfea9863b42860efaabb d08ec2974829271ce2390a2244ab40831a113e62 mnas-package-20221106-git mnas-package.asd
mnas-path http://beta.quicklisp.org/archive/mnas-path/2022-07-07/mnas-path-20220707-git.tgz 3272 7f33ea3a4bc17637c50ba83e2159778f 62fdc3b2d23864cdbe41b419a28afa9b16f1434a mnas-path-20220707-git mnas-path.asd
mnas-string http://beta.quicklisp.org/archive/mnas-string/2022-07-07/mnas-string-20220707-git.tgz 27050 41a4a574589ef3d3aee12ede195608d7 6bccab5417bbd603043c27b4c0bd673f6c3cfc75 mnas-string-20220707-git mnas-string.asd
mockingbird http://beta.quicklisp.org/archive/mockingbird/2021-10-20/mockingbird-20211020-git.tgz 8152 e78333b9010d51104f094d7b6e41d718 90ce36a82f42bf47eb9c87fd8f4694e4753673f5 mockingbird-20211020-git mockingbird-test.asd mockingbird.asd
modest-config http://beta.quicklisp.org/archive/modest-config/2018-02-28/modest-config-20180228-git.tgz 4144 25b0ea7d813ee8b806fd8ac434252ffd b899245e88298eb9bc042cd07237a6f1e6925af0 modest-config-20180228-git modest-config-test.asd modest-config.asd
modf http://beta.quicklisp.org/archive/modf/2020-09-25/modf-20200925-git.tgz 14580 1673e7f6d51c31b7e7a1e9807c41ef55 033e0677c969da7633fb47ad7d9cc99baaf4805e modf-20200925-git modf-test.asd modf.asd
modf-fset http://beta.quicklisp.org/archive/modf-fset/2015-06-08/modf-fset-20150608-git.tgz 2115 aec2b57d064522f5065597cd6619f851 0fb42b40b822fc95b98dacf7dcc86a0781f581cd modf-fset-20150608-git modf-fset-test.asd modf-fset.asd
modularize http://beta.quicklisp.org/archive/modularize/2020-04-27/modularize-20200427-git.tgz 11043 4b3df3353c21acebe1fc17a0c6c393ad 8558d187f31278c8c5d891e5132ac91a76c97bfd modularize-20200427-git modularize-test-module.asd modularize.asd
modularize-hooks http://beta.quicklisp.org/archive/modularize-hooks/2019-07-10/modularize-hooks-20190710-git.tgz 6119 86d8ed59bb2e6231b3c651372920128a 164b8063183939b2b42aa744e4280bca1a626f35 modularize-hooks-20190710-git modularize-hooks.asd
modularize-interfaces http://beta.quicklisp.org/archive/modularize-interfaces/2021-06-30/modularize-interfaces-20210630-git.tgz 11195 1f3722a166109f568e7a4c125cddacc9 b4bb691e94094e4bf9dead475c12d6c5850e4c42 modularize-interfaces-20210630-git interfaces-test-implementation.asd modularize-interfaces.asd
moira http://beta.quicklisp.org/archive/moira/2017-11-30/moira-20171130-git.tgz 2823 a1cfcd5ab13cc5dda524d0f5e26e90ce 6e26e71c89b4ecdef7218d572ebcf342a26052bb moira-20171130-git moira.asd
monkeylib-binary-data http://beta.quicklisp.org/archive/monkeylib-binary-data/2011-12-03/monkeylib-binary-data-20111203-git.tgz 4927 ef6b8e9c30e6b8efa915ca35ed962cf3 77232f96c8600789af74f006a7af9eb1fc6e698d monkeylib-binary-data-20111203-git com.gigamonkeys.binary-data.asd
monkeylib-html http://beta.quicklisp.org/archive/monkeylib-html/2018-02-28/monkeylib-html-20180228-git.tgz 7951 2b2b680f1eb02d4392135cebc33825fe 464b87c31dcfde60e5e350c7f2b5bab63bd3eb32 monkeylib-html-20180228-git monkeylib-html.asd
monkeylib-json http://beta.quicklisp.org/archive/monkeylib-json/2018-02-28/monkeylib-json-20180228-git.tgz 4329 253e4e5aa8fd634fc76c97e8b9be0862 56e485b956487256210d5eb76a3031f95d54335d monkeylib-json-20180228-git com.gigamonkeys.json.asd
monkeylib-macro-utilities http://beta.quicklisp.org/archive/monkeylib-macro-utilities/2011-12-03/monkeylib-macro-utilities-20111203-git.tgz 1968 b03c3644ff328ded7e7e0a39741a69ba 4bc771174bdb9bb52952356408d7a617e6b4ce2c monkeylib-macro-utilities-20111203-git com.gigamonkeys.macro-utilities.asd
monkeylib-markup http://beta.quicklisp.org/archive/monkeylib-markup/2012-09-09/monkeylib-markup-20120909-git.tgz 51056 e2f052930d4ed6cbd97b802b20a83646 fcf29d2e6a193626a8c5eb3d2498caf192735479 monkeylib-markup-20120909-git com.gigamonkeys.markup.asd
monkeylib-markup-html http://beta.quicklisp.org/archive/monkeylib-markup-html/2012-02-08/monkeylib-markup-html-20120208-git.tgz 4582 f70d4f0c511f36d6fc4a10a6912b51e0 d1fb1db716fdb7fe0fa845e223d0da5e76629b69 monkeylib-markup-html-20120208-git monkeylib-markup-html.asd
monkeylib-parser http://beta.quicklisp.org/archive/monkeylib-parser/2012-02-08/monkeylib-parser-20120208-git.tgz 22347 3e4327f25a31e78f93fd50de71b41065 48d5b2a1b8072d27c7601124a166fbadb2bc1bb4 monkeylib-parser-20120208-git com.gigamonkeys.parser.asd
monkeylib-pathnames http://beta.quicklisp.org/archive/monkeylib-pathnames/2012-02-08/monkeylib-pathnames-20120208-git.tgz 3689 9f7c261f5a6f3e594c8b63f3a81fd87e 8d3750393675bcd26b42b59cf20ca4e9127d55f2 monkeylib-pathnames-20120208-git com.gigamonkeys.pathnames.asd
monkeylib-prose-diff http://beta.quicklisp.org/archive/monkeylib-prose-diff/2014-07-13/monkeylib-prose-diff-20140713-git.tgz 68305 6c656fe2d6bcb7eaba029b23da783a53 d70a0717980660fb19691b8f40c02fb430187a67 monkeylib-prose-diff-20140713-git com.gigamonkeys.prose-diff.asd
monkeylib-test-framework http://beta.quicklisp.org/archive/monkeylib-test-framework/2010-12-07/monkeylib-test-framework-20101207-git.tgz 7237 cebe94d4ac359f39cf0eef63cf0e8de5 52d736e23f6a71c8ea987186c1f4c1b460c5a356 monkeylib-test-framework-20101207-git com.gigamonkeys.test-framework.asd
monkeylib-text-languages http://beta.quicklisp.org/archive/monkeylib-text-languages/2011-12-03/monkeylib-text-languages-20111203-git.tgz 5234 a5ff209ee992b4fe4685cabd3616bc49 9e02022e60dfbcfa4e2c7399dec3d4e579721383 monkeylib-text-languages-20111203-git monkeylib-text-languages.asd
monkeylib-text-output http://beta.quicklisp.org/archive/monkeylib-text-output/2011-12-03/monkeylib-text-output-20111203-git.tgz 3919 1d0623eadd80d9b0bbfa71b5a6d08d31 12de87a35e9dd6169d0201c3d17f07ab7d9bcd16 monkeylib-text-output-20111203-git monkeylib-text-output.asd
monkeylib-utilities http://beta.quicklisp.org/archive/monkeylib-utilities/2017-04-03/monkeylib-utilities-20170403-git.tgz 12151 323d5400fe092b0aff4be8d39c8bef33 9c55b7c6192c126ff49da725fdadeaf4e90a5d3c monkeylib-utilities-20170403-git com.gigamonkeys.utilities.asd
monomyth http://beta.quicklisp.org/archive/monomyth/2021-12-30/monomyth-20211230-git.tgz 376647 95fb3ac0c1cf6cab58712ad5325100a9 3f5aba56abdf0d98da9b166e3b9ac74aa34cce19 monomyth-20211230-git monomyth.asd
montezuma http://beta.quicklisp.org/archive/montezuma/2018-02-28/montezuma-20180228-git.tgz 1264435 db964cddda9b92877259d7db67c2aac3 37dd0718f7823760da2d72d050b39a38c56b4758 montezuma-20180228-git contrib/montezuma-indexfiles/montezuma-indexfiles.asd lucene-in-action/lucene-in-action-tests.asd montezuma.asd
moptilities http://beta.quicklisp.org/archive/moptilities/2017-04-03/moptilities-20170403-git.tgz 15618 b118397be325e60a772ea3631c4f19a4 a2b4eb6acad43773290ed22ee7698367476b01f5 moptilities-20170403-git moptilities-test.asd moptilities.asd
more-cffi http://beta.quicklisp.org/archive/more-cffi/2022-11-06/more-cffi-20221106-git.tgz 40492 7fcc1ededdc9d567350d3241840138a3 ff920de44043ea7fe3d4db0563858f1ab8291043 more-cffi-20221106-git more-cffi.asd
more-conditions http://beta.quicklisp.org/archive/more-conditions/2018-08-31/more-conditions-20180831-git.tgz 20791 c4797bd3c6c50fba02a6e8164ddafe28 d81093734a1f68b0ce022eaa1577334d22987390 more-conditions-20180831-git more-conditions.asd
mp3-duration http://beta.quicklisp.org/archive/mp3-duration/2016-02-08/mp3-duration-20160208-git.tgz 2763 fe74eb23d4016d798f4c7ab39fae1991 edeab1547d760345c92b49dbb707adf69c4e16a8 mp3-duration-20160208-git mp3-duration-test.asd mp3-duration.asd
mpc http://beta.quicklisp.org/archive/mpc/2016-09-29/mpc-20160929-git.tgz 22507 7a4be8c7f3c1a896d2fa06c6aff4accf fc09c11b6e330eee4d0435e1fe5a9d09c3d1c803 mpc-20160929-git mpc.asd
mra-wavelet-plot http://beta.quicklisp.org/archive/mra-wavelet-plot/2018-12-10/mra-wavelet-plot-20181210-git.tgz 2672 6e58c7f058b996710f89095bd7d55140 4824e4d538ea298a76d6c69f6df99782ce5e0b41 mra-wavelet-plot-20181210-git mra-wavelet-plot.asd
mstrings http://beta.quicklisp.org/archive/mstrings/2022-07-07/mstrings-20220707-git.tgz 6312 55b26e36430a3d813aa7c2fd8b13d1ef dee659b597d7cc4d92f7ae139502e29365b9c802 mstrings-20220707-git mstrings.asd
mt19937 http://beta.quicklisp.org/archive/mt19937/2011-02-19/mt19937-1.1.1.tgz 5551 54c63977b6d77abd66ebe0227b77c143 268d9a0d1dc870bd409bf9a85f80ff39840efd49 mt19937-1.1.1 mt19937.asd
mtif http://beta.quicklisp.org/archive/mtif/2017-11-30/mtif-20171130-git.tgz 36178 a713b90c4790464371cdc469d44a441f 8ee07bbf0c5b5fbfd618054945055ab638c7db57 mtif-20171130-git mtif.asd
mtlisp http://beta.quicklisp.org/archive/mtlisp/2013-06-15/mtlisp-20130615-git.tgz 41092 651cd99d4c77b0d533c1ee94e515b6b7 4d9ce6610ce99f89ddbfaea4d40a4369f8e1c8f8 mtlisp-20130615-git mtlisp.asd
multilang-documentation http://beta.quicklisp.org/archive/multilang-documentation/2019-07-10/multilang-documentation-20190710-git.tgz 7361 ba61cdd7a06d398143c4f18614c2b3a7 fa7caa1284353367149f88f1606465fa4357f49a multilang-documentation-20190710-git multilang-documentation.asd
multiple-value-variants http://beta.quicklisp.org/archive/multiple-value-variants/2014-08-26/multiple-value-variants-1.0.1.tgz 6991 b5676f66549832298262156277a79a52 b149d999e846c682677d7bbfbd3791c1baf73480 multiple-value-variants-1.0.1 multiple-value-variants.asd
multiposter http://beta.quicklisp.org/archive/multiposter/2022-11-06/multiposter-20221106-git.tgz 19794 13cb1bae8926c8607afb3077fbcdba0a 7523cb846b83b10cea7acf7f2b16aecb5c3f409d multiposter-20221106-git multiposter-git.asd multiposter-lichat.asd multiposter-mastodon.asd multiposter-studio.asd multiposter-tumblr.asd multiposter-twitter.asd multiposter.asd
multival-plist http://beta.quicklisp.org/archive/multival-plist/2012-03-05/multival-plist-20120305-git.tgz 2263 db7767930bc07a150b697a6b63c369db eb4c2b023fccebd18549008ad67aa1ce6d4ace09 multival-plist-20120305-git multival-plist-test.asd multival-plist.asd
music-spelling http://beta.quicklisp.org/archive/music-spelling/2022-11-06/music-spelling-20221106-git.tgz 11483 a2af2a4ae329feab49e73c9e44ed3fe1 bf548ffaaaaa631d45cdceb86683cb734e28d836 music-spelling-20221106-git music-spelling.asd
mutility http://beta.quicklisp.org/archive/mutility/2022-11-06/mutility-20221106-git.tgz 35424 891a9de6c3babf562b414b7b6771ce7c 8d30fbb659db48781a77d9b6913e8d0580448905 mutility-20221106-git mutility.asd
mw-equiv http://beta.quicklisp.org/archive/mw-equiv/2010-10-06/mw-equiv-0.1.3.tgz 6115 671497babfd44f6d9c5f0c02bddb457c 4a79edf2ca9f5e65daff7f37323da4f1055d914c mw-equiv-0.1.3 mw-equiv.asd
mystic http://beta.quicklisp.org/archive/mystic/2016-02-08/mystic-20160208-git.tgz 7566 c76b5583defbbc0a921332f496fee7c5 a0ddfaea0aea12b7ce41e05d446626cf02a5d99f mystic-20160208-git mystic-file-mixin.asd mystic-fiveam-mixin.asd mystic-gitignore-mixin.asd mystic-library-template.asd mystic-readme-mixin.asd mystic-test.asd mystic-travis-mixin.asd mystic.asd
myway http://beta.quicklisp.org/archive/myway/2022-11-06/myway-20221106-git.tgz 5354 81c32575181b11f9a9cb6a58ed6dbeea 11688394e718c5858c764149187dc77bfa95b250 myway-20221106-git myway-test.asd myway.asd
myweb http://beta.quicklisp.org/archive/myweb/2015-06-08/myweb-20150608-git.tgz 29572 bc91336495ca1421dac79bf14c5e6881 9e6e03663659d582aca58d1bfb7606952e9a7fcf myweb-20150608-git myweb.asd
nail http://beta.quicklisp.org/archive/nail/2022-11-06/nail-20221106-git.tgz 4591 bffd72a24d172c962811a58a9c859a13 903f5b0bae7563ade27c085bb8a7c45f73b47cd7 nail-20221106-git nail.asd
named-closure http://beta.quicklisp.org/archive/named-closure/2022-02-20/named-closure-20220220-git.tgz 4053 af2d8b666c94eba3c9b5cb00a5a8fb56 e1bd01c5f198b9d03cde10ede875870e63ae83e9 named-closure-20220220-git named-closure.asd
named-read-macros http://beta.quicklisp.org/archive/named-read-macros/2021-02-28/named-read-macros-20210228-git.tgz 7657 dd44f3c294853f9c24af31d627570322 ed1e062396638d39dba115f2d0284298efc42c1a named-read-macros-20210228-git named-read-macros.asd test/named-read-macros-test.asd
named-readtables http://beta.quicklisp.org/archive/named-readtables/2022-03-31/named-readtables-20220331-git.tgz 26611 2b66af7f6896d656f54333142905a8c4 f32763a63473c936d73186dbccf6641dc7e071a7 named-readtables-20220331-git named-readtables.asd
nanovg-blob http://beta.quicklisp.org/archive/nanovg-blob/2020-10-16/nanovg-blob-stable-git.tgz 1609829 624ef174d1d5c8f2d8145f37bce4628d f31f67c0c03317d104763e3857cc9cea45f36e80 nanovg-blob-stable-git nanovg-blob.asd
napa-fft3 http://beta.quicklisp.org/archive/napa-fft3/2015-12-18/napa-fft3-20151218-git.tgz 31959 4930569d5c4092ab11f76d8886779e6e 61afdce14dfe27431acbbd063c9840786b5e5d11 napa-fft3-20151218-git napa-fft3.asd
narrowed-types http://beta.quicklisp.org/archive/narrowed-types/2018-02-28/narrowed-types-20180228-git.tgz 2510 a149f985d2032c17210a3f75a9eca101 130b28978940159ed19df76eed1945738cfd1b05 narrowed-types-20180228-git narrowed-types-test.asd narrowed-types.asd
nbd http://beta.quicklisp.org/archive/nbd/2021-10-20/nbd-20211020-git.tgz 9417 9f5755497817a667537f5bbcde153512 6303fc53f5f55d1f268ee483ef98c41ef1df2758 nbd-20211020-git nbd.asd
ndebug http://beta.quicklisp.org/archive/ndebug/2022-11-06/ndebug-20221106-git.tgz 8504 358bf063dd8cafa15a6245814b2f8f2f 71d6dc0a2fff25db68f7fee55a7d52ce72261b87 ndebug-20221106-git ndebug.asd
neo4cl http://beta.quicklisp.org/archive/neo4cl/2022-07-07/neo4cl-20220707-git.tgz 30360 a45d7c7ef99fc3daef66f4bc39e5db1d 75bddb4e37ecf76779352f0f0ae6896b33d9b79e neo4cl-20220707-git src/neo4cl.asd test/neo4cl-test.asd
net-telent-date http://beta.quicklisp.org/archive/net-telent-date/2010-10-06/net-telent-date_0.42.tgz 12575 6fedf40113b2462f7bd273d07950066b 2a0efdd496136ba7d0d1d7b701ff57f9f0a0929f net-telent-date_0.42 net-telent-date.asd
network-addresses http://beta.quicklisp.org/archive/network-addresses/2016-06-28/network-addresses-20160628-git.tgz 4504 6b48746dc7beff85ed4b81edc4d31732 aa2e821a7e184fa885827db8b111896d641d3f6b network-addresses-20160628-git network-addresses-test.asd network-addresses.asd
neural-classifier http://beta.quicklisp.org/archive/neural-classifier/2022-11-06/neural-classifier-20221106-git.tgz 11679025 9edd6e0b50958715b1ccd3c68a37a856 19e1ceb983b1ab7b8fd06c4be1e0ecd2a9aac8f1 neural-classifier-20221106-git neural-classifier.asd
new-op http://beta.quicklisp.org/archive/new-op/2021-12-30/new-op-20211230-git.tgz 22320 e89f062e316e3aa7a603cebc839158d0 2067b28afb4bfb2c93102e90141c9b37791f7650 new-op-20211230-git new-op.asd
nfiles http://beta.quicklisp.org/archive/nfiles/2022-11-06/nfiles-20221106-git.tgz 23842 fafe96e733a2ae9d5f8753ee16f42ce6 b02050681eb60a60b8ab84f8b46dbbd20eb2450d nfiles-20221106-git nfiles.asd
nhooks http://beta.quicklisp.org/archive/nhooks/2022-11-06/nhooks-20221106-git.tgz 8128 4b3a3ab02ef2e3dd46bebb78a3108f23 58c2f6d267f34864e595fd10633b898f2aec07d2 nhooks-20221106-git nhooks.asd
nibbles http://beta.quicklisp.org/archive/nibbles/2022-03-31/nibbles-20220331-git.tgz 18758 cd021b794b24ef251e76a24cac0d59ab d637716caf748acb1a7b96b707ea99d4063ecc9c nibbles-20220331-git nibbles.asd
nibbles-streams http://beta.quicklisp.org/archive/nibbles-streams/2022-07-07/nibbles-streams-20220707-git.tgz 5442 f976be5c1724fe1a03df2c91454a62cc 55be2783a0b720662626249677ab01d737340745 nibbles-streams-20220707-git nibbles-streams.asd
nineveh http://beta.quicklisp.org/archive/nineveh/2019-10-07/nineveh-release-quicklisp-0a10a846-git.tgz 47692 c7c3fe5e3a5a3bb9e8e7de3086cf95bb 43962ced034bf55962f61fe06ba75c2dd85a47a6 nineveh-release-quicklisp-0a10a846-git nineveh.asd
ningle http://beta.quicklisp.org/archive/ningle/2021-12-30/ningle-20211230-git.tgz 7069 e5316c7625a24d0fe3a06662728404b0 e957b6b0c4c124472224b3881a5f8de9878bdbb6 ningle-20211230-git ningle-test.asd ningle.asd
nkeymaps http://beta.quicklisp.org/archive/nkeymaps/2022-11-06/nkeymaps-20221106-git.tgz 22102 57b9da47ee5f680f3ec63735406972e0 52f4a8547fdf8dbc3a196e69990c37ec6858cdc1 nkeymaps-20221106-git nkeymaps.asd
nlopt http://beta.quicklisp.org/archive/nlopt/2022-07-07/nlopt-20220707-git.tgz 16683 8ab078db93be79ffe8e47e1c4680b73a b744e8b75be537fe6350a53b9a4a9d3b7de36622 nlopt-20220707-git nlopt.asd
nodgui http://beta.quicklisp.org/archive/nodgui/2022-11-06/nodgui-20221106-git.tgz 132562 ece7c7f1a3c5bcfe08d3b058fafb73d3 f1f5a819d28515a7150d17e96f2817fc282832b0 nodgui-20221106-git nodgui.asd
north http://beta.quicklisp.org/archive/north/2021-04-11/north-20210411-git.tgz 53740 4b30a6586ad82afccca02394965588f8 4c60a8d95ccba345d242120bda7e82d73bc36eb5 north-20210411-git example/north-example.asd north-core.asd north-dexador.asd north-drakma.asd north.asd
nsort http://beta.quicklisp.org/archive/nsort/2015-05-05/nsort-20150505-git.tgz 1785 71e01656a21f61447e0298f89d3af456 912766fd5765889a4ce4a6a0b64fc2d14d29f63a nsort-20150505-git nsort.asd
nuclblog http://beta.quicklisp.org/archive/nuclblog/2014-08-26/nuclblog-20140826-git.tgz 20053 fb80583640212d0bfc452f9156917eac ffded3e808a703fdda65f3b3ab7c677c9be60946 nuclblog-20140826-git nuclblog.asd
nuklear-blob http://beta.quicklisp.org/archive/nuklear-blob/2020-10-16/nuklear-blob-stable-git.tgz 1137399 470a715768c9c23922c2ab6cd7f48785 7a778bccc113677eb465e18d16cb63efa14e7ba1 nuklear-blob-stable-git nuklear-blob.asd
nuklear-renderer-blob http://beta.quicklisp.org/archive/nuklear-renderer-blob/2020-10-16/nuklear-renderer-blob-stable-git.tgz 1042893 633ca88967148af18d77793c2727698b ca1eb34453d57a96bfd1b35b7dbf940afb970649 nuklear-renderer-blob-stable-git nuklear-renderer-blob.asd
null-package http://beta.quicklisp.org/archive/null-package/2022-07-07/null-package-20220707-git.tgz 9604 448486330acec3e6f54c3f20d19b2bb0 54e26bddc2f63ac20967bf4f2b132978de7dc73f null-package-20220707-git null-package.asd spec/null-package.test.asd
numcl http://beta.quicklisp.org/archive/numcl/2022-11-06/numcl-20221106-git.tgz 266962 f29d768d3febb64870ebdb335f4fa444 4ca347e38e7a13acb9e28299d948cbbb14aea799 numcl-20221106-git numcl.asd numcl.test.asd
numerical-utilities http://beta.quicklisp.org/archive/numerical-utilities/2022-11-06/numerical-utilities-20221106-git.tgz 657961 09416b45d6cc071813239c1a463c497e ad8353d5fe74c1fa9d79a5ef2c681d6c1cac2ea9 numerical-utilities-20221106-git num-utils.asd
numericals http://beta.quicklisp.org/archive/numericals/2022-11-06/numericals-2022.09.0.tgz 253072 925a2a43a4510a881d7c6c598011fa71 2414b35577e1bd8c4cb18899520aeb25b6796a73 numericals-2022.09.0 dense-numericals.asd numericals.asd numericals.common.asd
numpy-file-format http://beta.quicklisp.org/archive/numpy-file-format/2021-01-24/numpy-file-format-20210124-git.tgz 5141 0d81ce1e67ed1323787eb0f3cd698113 d47cb6bd3871541cfdfec2c460c6f4056d507c1d numpy-file-format-20210124-git code/numpy-file-format.asd
nyaml http://beta.quicklisp.org/archive/nyaml/2021-12-30/nyaml-20211230-git.tgz 169260 3bfbf82accf389ed820952c2a6932703 f1749e7c5cae3525e0a03bf5dfed4fd5226ba67f nyaml-20211230-git nyaml.asd
nyxt http://beta.quicklisp.org/archive/nyxt/2022-11-06/nyxt-20221106-git.tgz 20365848 b7aa66e132f3153fd9eb5cec92307328 743e91d824d3249a91218c7cca6adfab26c90159 nyxt-20221106-git nyxt-asdf.asd nyxt-ubuntu-package.asd nyxt.asd
object-class http://beta.quicklisp.org/archive/object-class/2020-09-25/object-class_1.0.tgz 6010 f0defa601fa8bc627810f12a0a8dff83 d45fdb627c0c0d0ae53ea36fe79797232d168a09 object-class_1.0 object-class.asd tests/object-class_tests.asd
oclcl http://beta.quicklisp.org/archive/oclcl/2019-05-21/oclcl-20190521-git.tgz 171806 3e1768e4d9c1412aabd19fc23457ca8f 2f49a21ab843dc52b012a82c286142994c122e95 oclcl-20190521-git oclcl-examples.asd oclcl-test.asd oclcl.asd
ode-blob http://beta.quicklisp.org/archive/ode-blob/2020-10-16/ode-blob-stable-git.tgz 3753751 10ebb08bdcf76faa8f3313127022b830 e501970718de3c605a2e6b9766ccc9be841ee57e ode-blob-stable-git ode-blob.asd
oe-encode http://beta.quicklisp.org/archive/oe-encode/2015-08-04/oe-encode-20150804-git.tgz 49756 317e7cb5295306a3b64a7b5cfe673093 1d2ad0214c58b88ddff8c2f66e8ef1d89b6de0ba oe-encode-20150804-git oe-encode.asd
olc http://beta.quicklisp.org/archive/olc/2022-03-31/olc-20220331-git.tgz 14971 9d8413918a443fb026da8c5adc3bbcc9 65fd78043489f678f39a7ab03802731cabfefd26 olc-20220331-git olc.asd
omer-count http://beta.quicklisp.org/archive/omer-count/2021-04-11/omer-count-20210411-git.tgz 15326 091d8e3b9fc957d64a6e1e590db65e84 b0b1bc0e6a5c40e1e8bfa9506184a8fb0972b077 omer-count-20210411-git eclecticse.omer.asd
omglib http://beta.quicklisp.org/archive/omglib/2022-11-06/omglib-20221106-git.tgz 341846 dfc418ecd614c05e8c55c17d679f5068 d8ad6f1f2322174b21c7c0854a77c96a5a118f8a omglib-20221106-git omg.asd
one-more-re-nightmare http://beta.quicklisp.org/archive/one-more-re-nightmare/2022-11-06/one-more-re-nightmare-20221106-git.tgz 42434 e6231f8ce3fa544619e511cf1a6dcdb4 56c034f5a7211a384b94bd95e2c7f03a9a93154e one-more-re-nightmare-20221106-git Code/SIMD/one-more-re-nightmare-simd.asd Code/one-more-re-nightmare.asd Tests/one-more-re-nightmare-tests.asd
oneliner http://beta.quicklisp.org/archive/oneliner/2013-10-03/oneliner-20131003-git.tgz 3129 8709f2596797542709d9fc02e557d8c2 b2c7d3ee581dc13e43cf14a85b1f3e0bca093625 oneliner-20131003-git cl-oneliner.asd
ook http://beta.quicklisp.org/archive/ook/2021-12-30/ook-20211230-git.tgz 13971 7f7c07047e56c9b2636719815368ebb1 6b14baaaf11dbc892529b2df507d3e2b1ca76b57 ook-20211230-git ook.asd
oook http://beta.quicklisp.org/archive/oook/2017-11-30/oook-20171130-git.tgz 12023 eb6ee68a5f48b3720d7285fae7336485 b368840c0547253cb2c82e9ef9c48ffd27fed565 oook-20171130-git oook.asd
open-location-code http://beta.quicklisp.org/archive/open-location-code/2022-03-31/open-location-code-20220331-git.tgz 16351 e0acb3f7e60d6c3929e0df66748b9da1 a09956a30c4a26d2f79f1dea505ab925d2515ba1 open-location-code-20220331-git open-location-code.asd
open-vrp http://beta.quicklisp.org/archive/open-vrp/2014-09-14/open-vrp-20140914-git.tgz 925579 718ad8132bb06eb5a66b1c1a814b7e66 066d3adb2be495e1a76dadf9e55ec2e66519715c open-vrp-20140914-git open-vrp-lib.asd open-vrp.asd
openal-blob http://beta.quicklisp.org/archive/openal-blob/2020-10-16/openal-blob-stable-git.tgz 4536591 5c3002b5d6963821c12f32aceeb62a45 a1b567c9192e91126defaed59e01e94e7552ac02 openal-blob-stable-git openal-blob.asd
openid-key http://beta.quicklisp.org/archive/openid-key/2018-12-10/openid-key-20181210-git.tgz 3284 cbe196eef93ee9eec7ef117557c440b2 4cdb875b541259e7bb9bbf8d26244f3dba1078b2 openid-key-20181210-git openid-key-test.asd openid-key.asd
ops5 http://beta.quicklisp.org/archive/ops5/2020-02-18/ops5-20200218-git.tgz 42739 89d7d0549272c77f000543b8bc2a5818 e37e16211f574db5815deacbe27708b5af08f592 ops5-20200218-git ops5.asd
opticl http://beta.quicklisp.org/archive/opticl/2022-02-20/opticl-20220220-git.tgz 254013 82143b7ab0bde3d8927d02e085110d86 0471b29b88942e454a067b9edae876c81b03dbbf opticl-20220220-git opticl-doc.asd opticl.asd
opticl-core http://beta.quicklisp.org/archive/opticl-core/2017-10-19/opticl-core-20171019-git.tgz 4502 612766d24e14244a87d0bf41a789ed5a 90fe1cccff0248626018b5634abdf717f5e8c445 opticl-core-20171019-git opticl-core.asd
optima http://beta.quicklisp.org/archive/optima/2015-07-09/optima-20150709-git.tgz 20345 20523dc3dfc04bb2526008dff0842caa aec56f162a6b34024d0b419ed9dfb35ef9e75be6 optima-20150709-git optima.asd optima.ppcre.asd optima.test.asd
org-davep-dict http://beta.quicklisp.org/archive/org-davep-dict/2019-05-21/org-davep-dict-20190521-git.tgz 6731 a5c307e394ddaf3dc23fd415fb025e04 84ce779221666927b4e07aaa47fcd26fb24f7bf0 org-davep-dict-20190521-git org-davep-dict.asd
org-davep-dictrepl http://beta.quicklisp.org/archive/org-davep-dictrepl/2019-05-21/org-davep-dictrepl-20190521-git.tgz 2983 311107f58978970b214e575690815a62 89eb453c83abfd72dd4c6a821a5b9704794e2fab org-davep-dictrepl-20190521-git org-davep-dictrepl.asd
org-sampler http://beta.quicklisp.org/archive/org-sampler/2016-03-18/org-sampler-0.2.0.tgz 61604 1d367f79a5cb325abce3e1640ce6bc91 e7e572deb75c9bb2f55bdca3a5915bf1fb4440da org-sampler-0.2.0 org-sampler.asd
origin http://beta.quicklisp.org/archive/origin/2022-07-07/origin-20220707-git.tgz 57816 98b0478d6f42d8f770b735633b76db07 20ba394ed81f9052a1d4ad3817bff9858f8ca6f3 origin-20220707-git origin.asd origin.test.asd
orizuru-orm http://beta.quicklisp.org/archive/orizuru-orm/2021-02-28/orizuru-orm-20210228-git.tgz 49633 12546f2f34c3a1741d46c6dbd0ad3214 e3b50e1342662685f3fcfb20f55d328d8a9c65f4 orizuru-orm-20210228-git orizuru-orm.asd
osc http://beta.quicklisp.org/archive/osc/2022-11-06/osc-20221106-git.tgz 32272 f4f9004af28c93ddad2028583d36ac30 5811d4a69f4fd5ebc514a6cfb076d106b6518f53 osc-20221106-git osc.asd
osicat http://beta.quicklisp.org/archive/osicat/2022-11-06/osicat-20221106-git.tgz 66382 c47a0276c7d611414b7b54795328d404 f0f554fe5dd8931f0d61a0615293f76e8e1b8151 osicat-20221106-git osicat.asd
osmpbf http://beta.quicklisp.org/archive/osmpbf/2021-06-30/osmpbf-20210630-git.tgz 23232 75378297ea30adbe7eeb445be1e4d67a 94186bfaf2de9de1815501018e887c2ec60fcf29 osmpbf-20210630-git osmpbf.asd
ospm http://beta.quicklisp.org/archive/ospm/2022-11-06/ospm-20221106-git.tgz 12048 be9b4545e53d5856b8c7bd2192540573 ad0125818ea4af6f79992e9e987a8bc07eeff2eb ospm-20221106-git ospm.asd
overlord http://beta.quicklisp.org/archive/overlord/2022-11-06/overlord-20221106-git.tgz 57402 1e960f3e57f5af90013fe350bda2b8e2 b54c5203d5d702ac41d464ca02a0359dd82dcd38 overlord-20221106-git overlord.asd
oxenfurt http://beta.quicklisp.org/archive/oxenfurt/2019-07-10/oxenfurt-20190710-git.tgz 23362 d3399266edf13969b0031f972a15477f 146d6718296832a33ebd25076d743677b4a74a95 oxenfurt-20190710-git oxenfurt-core.asd oxenfurt-dexador.asd oxenfurt-drakma.asd oxenfurt.asd
pack http://beta.quicklisp.org/archive/pack/2011-06-19/pack-20110619-git.tgz 3684 f769fa83d8487575facf6fe5adf9b245 e33f75deac5ab3a1facc24fc378c9184b6be6d04 pack-20110619-git pack.asd
package-renaming http://beta.quicklisp.org/archive/package-renaming/2012-04-07/package-renaming-20120407-git.tgz 4522 b9d7b446196fba632edd088bf9ad23ae bcba6923289ab9cf2f539dec333853ff7d9e0a65 package-renaming-20120407-git package-renaming-test.asd package-renaming.asd
packet http://beta.quicklisp.org/archive/packet/2015-03-02/packet-20150302-git.tgz 10533 71312a40fa6abb7027b94c8a57a90d00 5c459eb3feebdfed53359a7b021cba522ae6df71 packet-20150302-git packet.asd
packet-crafting http://beta.quicklisp.org/archive/packet-crafting/2020-06-10/packet-crafting-20200610-git.tgz 2785 aaa0333dddfcc5e25e44edffbb993513 32c3e7f30ad90505371082fce4921c2a2f4bbc44 packet-crafting-20200610-git packet-crafting.asd
paiprolog http://beta.quicklisp.org/archive/paiprolog/2018-02-28/paiprolog-20180228-git.tgz 172150 1f04f011c9f09d7fe854b98e845d21bd e5505fd5ff9fb77bf6e3374ab0d5e9e37cc7186a paiprolog-20180228-git paiprolog.asd unifgram.asd
pal http://beta.quicklisp.org/archive/pal/2015-06-08/pal-20150608-git.tgz 3707918 ce7afd79040188475efc67ae87287949 795d4e4f69cb4132ee35b641e564ee01ab6365d9 pal-20150608-git examples/bermuda/bermuda.asd pal.asd
pandocl http://beta.quicklisp.org/archive/pandocl/2015-09-23/pandocl-20150923-git.tgz 2581 ee9450a491206f3c606c05bb63268c08 613046a725fc6925372f484d1771c6acf4b74b0d pandocl-20150923-git pandocl.asd
pango-markup http://beta.quicklisp.org/archive/pango-markup/2020-03-25/pango-markup-20200325-git.tgz 9297 148111aed4d8c504e5e5e1fd7f929c71 82e509817917e36c1d65caf4e91033afe1791e34 pango-markup-20200325-git pango-markup.asd
papyrus http://beta.quicklisp.org/archive/papyrus/2022-11-06/papyrus-20221106-git.tgz 74977 a57110e7ef84d5b136db446c34ff1cf5 b276e1811dce38072e48978c9fcd1aa21c709de9 papyrus-20221106-git papyrus.asd
parachute http://beta.quicklisp.org/archive/parachute/2022-11-06/parachute-20221106-git.tgz 54319 32099128f615779709cac6d888b127e3 0a0460fed7f401bd506cebbbbc1f44a60b6435c1 parachute-20221106-git compat/parachute-fiveam.asd compat/parachute-lisp-unit.asd compat/parachute-prove.asd parachute.asd
parameterized-function http://beta.quicklisp.org/archive/parameterized-function/2019-03-07/parameterized-function-20190307-hg.tgz 3178 13de98b8381cd84c9cad3dde122e919a d0ee504ad9a10a393ff6326f1885ebfd16981149 parameterized-function-20190307-hg parameterized-function.asd
paren-files http://beta.quicklisp.org/archive/paren-files/2011-04-18/paren-files-20110418-git.tgz 11665 cf10bbcfa01d65e1487b2764d3967aeb 136c1ec5faace0cb6642fde48c9c8c317e0a3b91 paren-files-20110418-git paren-files.asd
paren-test http://beta.quicklisp.org/archive/paren-test/2017-08-30/paren-test-20170830-git.tgz 2796 1699edb46292e81cc416a717d42eb13a 8337b21fd440117d26c77f1ce1c6c3d81ec49265 paren-test-20170830-git examples/arith.asd paren-test.asd
paren-util http://beta.quicklisp.org/archive/paren-util/2011-04-18/paren-util-20110418-git.tgz 9583 ce8212375a6586235774baa4f7cfc4c5 1928ce6c595d307357e01e49fd47c32993b8562e paren-util-20110418-git paren-util.asd
paren6 http://beta.quicklisp.org/archive/paren6/2022-03-31/paren6-20220331-git.tgz 12264 9d3bfbdad61668c691622d7ac25ae67d 4018882007e03814de6649d2cbb2d2602522db41 paren6-20220331-git paren6.asd test-paren6.asd
parenml http://beta.quicklisp.org/archive/parenml/2015-09-23/parenml-20150923-git.tgz 2084 e02a5cb32d6ceda30744c90589b854cb 87db838f002b09178393e5162ebf681b43d23be6 parenml-20150923-git parenml-test.asd parenml.asd
parenscript http://beta.quicklisp.org/archive/parenscript/2018-12-10/Parenscript-2.7.1.tgz 103952 047c9a72bd36f1b4a5ec67af9453a0b9 2532046ecb26bcbc808bf8ed2d14d140a9a33fba Parenscript-2.7.1 parenscript.asd parenscript.tests.asd
parenscript-classic http://beta.quicklisp.org/archive/parenscript-classic/2011-12-03/parenscript-classic-20111203-darcs.tgz 185472 9d355c65babf238bdce498ff628e187b 3ea1563d8e21583c48b31677797e99b74fd31492 parenscript-classic-20111203-darcs parenscript-classic.asd
parse http://beta.quicklisp.org/archive/parse/2020-09-25/parse-20200925-git.tgz 7379 29779e94f9d0253b2c1d4fedf09801eb eb16fbc5dfc002b6428470446ada1a245a04674a parse-20200925-git parse.asd
parse-declarations http://beta.quicklisp.org/archive/parse-declarations/2010-10-06/parse-declarations-20101006-darcs.tgz 36664 e49222003e5b59c5c2a0cf58b86cfdcd f2ed7dbb076058e4aef57553469759b13a0a618c parse-declarations-20101006-darcs parse-declarations-1.0.asd
parse-float http://beta.quicklisp.org/archive/parse-float/2020-02-18/parse-float-20200218-git.tgz 4653 149e40a8c5fd6ab0e43242cb898d66bf 8031b1b03c4861658df12660cf2465e195af4bce parse-float-20200218-git parse-float.asd
parse-front-matter http://beta.quicklisp.org/archive/parse-front-matter/2016-08-25/parse-front-matter-20160825-git.tgz 1378 478c27505370135f5d8859fe5c755431 2da48a358580ac203b5762acdce7eb3e6516f39b parse-front-matter-20160825-git parse-front-matter-test.asd parse-front-matter.asd
parse-js http://beta.quicklisp.org/archive/parse-js/2016-04-21/parse-js-20160421-git.tgz 10664 14049fdc5f55bf48d7e3d54a9549a97e c6baef888b9383b2d437d31426f231de8a31b064 parse-js-20160421-git parse-js.asd
parse-number http://beta.quicklisp.org/archive/parse-number/2018-02-28/parse-number-v1.7.tgz 5715 b9ec925018b8f10193d73403873dde8f 472816dd6ad673d3be65ae33495c5378ba6b6588 parse-number-v1.7 parse-number.asd
parse-number-range http://beta.quicklisp.org/archive/parse-number-range/2012-11-25/parse-number-range-1.0.tgz 5733 a1a173bffeafcdca9320473f14103f80 c79d229ba4d3a0c5267b21b3560026b78a8c2300 parse-number-range-1.0 parse-number-range.asd
parseltongue http://beta.quicklisp.org/archive/parseltongue/2013-03-12/parseltongue-20130312-git.tgz 27941 4519905cf797085c6063c33bf0107b9c 3f9099ad7ee505fe0b8abaaca1e32d03bf6892b0 parseltongue-20130312-git parseltongue.asd
parseq http://beta.quicklisp.org/archive/parseq/2021-05-31/parseq-20210531-git.tgz 40928 a62fdb0623450f7ef82297e8b23fd343 8337a8abcb1e481150dd3580cb2d78f2fe16303c parseq-20210531-git parseq.asd
parser.common-rules http://beta.quicklisp.org/archive/parser.common-rules/2020-07-15/parser.common-rules-20200715-git.tgz 18930 6391d962ae6fc13cc57312de013504c5 71e704909ca1940d80e48c78f44d95c1fed4abe8 parser.common-rules-20200715-git parser.common-rules.asd parser.common-rules.operators.asd
parser.ini http://beta.quicklisp.org/archive/parser.ini/2018-10-18/parser.ini-20181018-git.tgz 11142 83943b433684f7bef2ad113adef8e4fd 60010609b62b382abbdda31e8824ab3026a42ffe parser.ini-20181018-git parser.ini.asd
parsnip http://beta.quicklisp.org/archive/parsnip/2022-03-31/parsnip-20220331-git.tgz 99114 9643c293d4e4dc62a11a2e581f8ce607 5bb773de88a22430bc661a1c971ea8c7e1a1a35d parsnip-20220331-git parsnip.asd
patchwork http://beta.quicklisp.org/archive/patchwork/2022-07-07/patchwork-20220707-git.tgz 5333 543fe66067f4a2ef1560eea4732ded06 497acf28e04ed585df383d37dadce415b14aeb16 patchwork-20220707-git patchwork.asd
path-parse http://beta.quicklisp.org/archive/path-parse/2016-04-21/path-parse-20160421-git.tgz 2115 83ace94d06e0759f717bf11be698602e 331bfeef1557fa4133220cac48bf4afb4f62a8da path-parse-20160421-git path-parse-test.asd path-parse.asd
path-string http://beta.quicklisp.org/archive/path-string/2016-08-25/path-string-20160825-git.tgz 4983 bc3d1e818a793d955eb6877f67bd4d52 833c85edc0fffcfcef2a9b5cfd111910c648293a path-string-20160825-git path-string-test.asd path-string.asd
pathname-utils http://beta.quicklisp.org/archive/pathname-utils/2022-11-06/pathname-utils-20221106-git.tgz 19971 22c2d4179b5b4f69df3b88f1ee0b6106 475930c915922e9e3655df3fc0fa2d1588b6f702 pathname-utils-20221106-git pathname-utils-test.asd pathname-utils.asd
patron http://beta.quicklisp.org/archive/patron/2013-04-20/patron-20130420-git.tgz 12195 dd08fa2247852002f9884ccc842aeae4 6d2f8130f0ab4eab47b9aba79e3cc060ef6da096 patron-20130420-git patron.asd
pcall http://beta.quicklisp.org/archive/pcall/2010-10-06/pcall-0.3.tgz 14561 019d85dfd1d5d0ee8d4ee475411caf6b 65626582e38d7a8b3180382a694a96290fde4b2c pcall-0.3 pcall-queue.asd pcall.asd
percent-encoding http://beta.quicklisp.org/archive/percent-encoding/2012-10-13/percent-encoding-20121013-git.tgz 5240 de4b28564907c12b598630d27135d80f c945ddb56afaf0244019242f77e396edfe870e1f percent-encoding-20121013-git percent-encoding.asd
perceptual-hashes http://beta.quicklisp.org/archive/perceptual-hashes/2022-07-07/perceptual-hashes-20220707-git.tgz 77319 4bad0585364e19336b3ccc82d4b00bba ff2c8aad83ce7818e56fb020cca4c9b18c22b42c perceptual-hashes-20220707-git perceptual-hashes.asd
periodic-table http://beta.quicklisp.org/archive/periodic-table/2011-10-01/periodic-table-1.0.tgz 5100 1fe8e203b8b622857fe1af4ade13e7ce 1f118c131789908e9108b84e72c2e1325f1ee22e periodic-table-1.0 periodic-table.asd
periods http://beta.quicklisp.org/archive/periods/2022-11-06/periods-20221106-git.tgz 33407 555ac25b534463a627b87f09d0cd6253 0c4d7db8501e8be163e1e2051e81d3d545d9a460 periods-20221106-git periods-series.asd periods.asd
perlre http://beta.quicklisp.org/archive/perlre/2020-07-15/perlre-20200715-git.tgz 7494 c441e4b9618789d3e6ffeadc9561c334 9799c4194934eee14732c91eb8c1bd56ec85f5bd perlre-20200715-git perlre.asd
pero http://beta.quicklisp.org/archive/pero/2022-11-06/pero-20221106-git.tgz 2838 e5c66fba10ad4b83e3d3cbffe0ddff91 17e9742da08cffc023b11b932d5403141a56428a pero-20221106-git pero.asd
persistent-tables http://beta.quicklisp.org/archive/persistent-tables/2012-02-08/persistent-tables-20120208-git.tgz 2585 08f6feb0c4716102d9f4c0ebe817a7be d53ebc25f643ca4ff4f4dda34421ddd1f6a2137c persistent-tables-20120208-git persistent-tables.asd
persistent-variables http://beta.quicklisp.org/archive/persistent-variables/2013-03-12/persistent-variables-20130312-git.tgz 117127 ba06997b04bdbeee85fc8861e0cdf687 ac9009d2637c21140d015c84b88200659808a7e1 persistent-variables-20130312-git persistent-variables.asd
petalisp http://beta.quicklisp.org/archive/petalisp/2022-11-06/petalisp-20221106-git.tgz 184416 951cce15b60a9894d62414550562df32 acb872e9292019a1bb07f6f68d810b18220c8bd5 petalisp-20221106-git code/api/petalisp.api.asd code/core/petalisp.core.asd code/graphviz/petalisp.graphviz.asd code/ir/petalisp.ir.asd code/petalisp.asd code/test-suite/petalisp.test-suite.asd code/type-inference/petalisp.type-inference.asd code/utilities/petalisp.utilities.asd code/xmas-backend/petalisp.xmas-backend.asd examples/petalisp.examples.asd
petit.package-utils http://beta.quicklisp.org/archive/petit.package-utils/2014-08-26/petit.package-utils-20140826-git.tgz 2290 58e6dceab797eec3cea779e5fb366486 f8a4735180f1d47481349ed8801433a4a6a5a8df petit.package-utils-20140826-git petit.package-utils.asd
petit.string-utils http://beta.quicklisp.org/archive/petit.string-utils/2014-11-06/petit.string-utils-20141106-git.tgz 4262 dea2dea0ac8045a1930a81231a1ac39b 8169426736e26e55f30171560c3b0e17c0175eea petit.string-utils-20141106-git petit.string-utils-test.asd petit.string-utils.asd
petri http://beta.quicklisp.org/archive/petri/2020-04-27/petri-20200427-git.tgz 139139 07ab9ed43e146849dcf32f2a8f06cc40 fc87e5028922295ca9967c44b8f88c56327d2804 petri-20200427-git petri.asd
pettomato-deque http://beta.quicklisp.org/archive/pettomato-deque/2012-01-07/pettomato-deque-20120107-git.tgz 5573 f4aebae99019f5ca7c82fec60540bbd9 7f132a9c5c15aac2d555bc1c19570973d32eb5c3 pettomato-deque-20120107-git pettomato-deque-tests.asd pettomato-deque.asd
pettomato-indexed-priority-queue http://beta.quicklisp.org/archive/pettomato-indexed-priority-queue/2012-09-09/pettomato-indexed-priority-queue-20120909-git.tgz 7555 f734b68ce8cdb911562cdd62eed1d5aa fdeebe7c9c560e4c559c18ba9ee833310685a1eb pettomato-indexed-priority-queue-20120909-git pettomato-indexed-priority-queue-tests.asd pettomato-indexed-priority-queue.asd
pg http://beta.quicklisp.org/archive/pg/2015-06-08/pg-20150608-git.tgz 48921 11a6ddac157a7443155158e255a2452b 6e5a808a1b08d0049450724574058280cf3a8a2d pg-20150608-git pg.asd
pgloader http://beta.quicklisp.org/archive/pgloader/2022-11-06/pgloader-v3.6.9.tgz 3710890 18bd05a740af2cd5c327732f9a793efe b45c084262645f7cfae11f0761f49792cc14abd4 pgloader-v3.6.9 pgloader.asd
phoe-toolbox http://beta.quicklisp.org/archive/phoe-toolbox/2021-01-24/phoe-toolbox-20210124-git.tgz 11392 43058ff6121fdc5b91a60c7f7223fb4d 860947b7239e2a2dc8795aeec55f86fda638724e phoe-toolbox-20210124-git phoe-toolbox.asd
phos http://beta.quicklisp.org/archive/phos/2022-02-20/phos-20220220-git.tgz 6059 34e65de883f34a39fcbe9d97e4bb7b12 e197369e7d65b226ec60cf08e58dd062e016de46 phos-20220220-git phos.asd
physical-quantities http://beta.quicklisp.org/archive/physical-quantities/2021-10-20/physical-quantities-20211020-git.tgz 29571 a322db845056f78a237630a565b41490 28a95f39d0aab6007d00f498e8ce9ed0c4c533bc physical-quantities-20211020-git physical-quantities.asd
picl http://beta.quicklisp.org/archive/picl/2021-01-24/picl-20210124-git.tgz 14029 7647fb7da88b067b365cc52138887e1a 0b05a7e8e6f1711c24247fa4140a6ccc730ef408 picl-20210124-git picl.asd
piggyback-parameters http://beta.quicklisp.org/archive/piggyback-parameters/2020-06-10/piggyback-parameters-20200610-git.tgz 6875 470a00d9671d91458573bbbe2ccba65b a53ed83556517233b71d88c12b0166539b2fb015 piggyback-parameters-20200610-git piggyback-parameters.asd
pileup http://beta.quicklisp.org/archive/pileup/2015-07-09/pileup-20150709-git.tgz 20217 230aeb8bbb0993c5fecd4ef47052623f 045fe18800b0e56283617fa5b032c483f38be280 pileup-20150709-git pileup.asd
pipes http://beta.quicklisp.org/archive/pipes/2015-09-23/pipes-20150923-git.tgz 5603 77717361af87e7a83d38e84d08ad29f5 e7ce78dc510136ebd0b8b6a7495fac662233a363 pipes-20150923-git pipes.asd
piping http://beta.quicklisp.org/archive/piping/2022-11-06/piping-20221106-git.tgz 9601 5cb995feb994d83e6ed72500a11a3437 f36e8247a01218b1162f4dd11456fbb985508bba piping-20221106-git piping.asd
pithy-xml http://beta.quicklisp.org/archive/pithy-xml/2010-10-06/pithy-xml-20101006-git.tgz 10188 5401547ac31ab9c502d3409a9200a0dc 9445d371b1e0801e3e75ff112f8ba551bb372276 pithy-xml-20101006-git pithy-xml.asd
pjlink http://beta.quicklisp.org/archive/pjlink/2022-03-31/pjlink-20220331-git.tgz 16106 80ae9df50eec86d567ae95d26b603d25 38152bbe3b603ff0a90e8ff02599cfa0388123e2 pjlink-20220331-git src/pjlink.asd
pk-serialize http://beta.quicklisp.org/archive/pk-serialize/2022-11-06/pk-serialize-20221106-git.tgz 8573 cd30a8f0ab67f15637a865aae63c88be fb03d2d7b419b5e3b2815da288166db4212a86ca pk-serialize-20221106-git pk-serialize.asd
pkg-doc http://beta.quicklisp.org/archive/pkg-doc/2020-09-25/pkg-doc-20200925-git.tgz 18257 28fedd7417265067bfe9602b634957e7 af9f4d14eb96e6b39a36c9005f2337f3787ca4f7 pkg-doc-20200925-git pkg-doc.asd
place-modifiers http://beta.quicklisp.org/archive/place-modifiers/2012-11-25/place-modifiers-2.1.tgz 10202 8c209e6ee7e376b20b447a4e75fb12e3 3a15cc3cd06e587cb81222057b99efa0a27a1545 place-modifiers-2.1 place-modifiers.asd
place-utils http://beta.quicklisp.org/archive/place-utils/2018-10-18/place-utils-0.2.tgz 14315 5462562949ab3a8b5a9f40e9e6d2a628 164c95f8afeab6e8ddf256f1f845108665035fa0 place-utils-0.2 place-utils.asd
plain-odbc http://beta.quicklisp.org/archive/plain-odbc/2019-11-30/plain-odbc-20191130-git.tgz 60040 cfa0da32a083a406344e6f6504d962de 9a7a0ce75ac9e1ef7c2fddc0705a1b2429196400 plain-odbc-20191130-git plain-odbc.asd
planks http://beta.quicklisp.org/archive/planks/2011-05-22/planks-20110522-git.tgz 13152 b0881e48b242ea36e95a815ba6118950 6fd7b423ace8306647696ae42d465683bec59e1a planks-20110522-git planks.asd
plexippus-xpath http://beta.quicklisp.org/archive/plexippus-xpath/2019-05-21/plexippus-xpath-20190521-git.tgz 56479 eb9a4c39a7c37aa0338c401713b3f944 6acb71007298138bb494e04abe39a79fff54af86 plexippus-xpath-20190521-git xpath.asd
plokami http://beta.quicklisp.org/archive/plokami/2020-02-18/plokami-20200218-git.tgz 20037 09cc4ee4c130da33562f277b56418b33 610357b49e11de7666e88ad9747dd478669b0ced plokami-20200218-git plokami.asd
plot http://beta.quicklisp.org/archive/plot/2022-11-06/plot-20221106-git.tgz 474948 69d0125bf90b674b0be3f58a8747a23f 0db73bdd6c2d1403f45f60b0e2006cd6c6174ccf plot-20221106-git plot.asd
pludeck http://beta.quicklisp.org/archive/pludeck/2018-08-31/pludeck-20180831-git.tgz 5125 7cc744ed744245026604347abf01a539 3bed71c98b172d330579aaa8833575f9f7b5b7f3 pludeck-20180831-git pludeck.asd
plump http://beta.quicklisp.org/archive/plump/2022-11-06/plump-20221106-git.tgz 51130 7a4ee4bbc31fd0f8aade976b1b859695 9ab30558590dde9c91e371bdb9cb3ce4c8d3522d plump-20221106-git plump-dom.asd plump-lexer.asd plump-parser.asd plump.asd
plump-bundle http://beta.quicklisp.org/archive/plump-bundle/2019-07-10/plump-bundle-20190710-git.tgz 7705 a89ccc2557c1657fa080302d5c929a6d 7a4b27d045b483bfc99ecfd43e5084bc6b985e60 plump-bundle-20190710-git plump-bundle.asd
plump-sexp http://beta.quicklisp.org/archive/plump-sexp/2021-05-31/plump-sexp-20210531-git.tgz 3716 651ef53b4b258971de4ca66a299a5157 3a961ac6f4414379688d9c05d0cd105a743a8691 plump-sexp-20210531-git plump-sexp.asd
plump-tex http://beta.quicklisp.org/archive/plump-tex/2021-05-31/plump-tex-20210531-git.tgz 3505 31f9b03d00f414b4e823e72adee1369a 56c4e93b1491ec7a76b74cb32dc12afa3138b066 plump-tex-20210531-git plump-tex-test.asd plump-tex.asd
png-read http://beta.quicklisp.org/archive/png-read/2017-08-30/png-read-20170830-git.tgz 8677 40354aa5f3f3321a4d42629c15c6f9f7 d36071bb47abcda177284afddd83cf518d579b19 png-read-20170830-git png-read.asd
pngload http://beta.quicklisp.org/archive/pngload/2022-07-07/pngload-20220707-git.tgz 106560 c25e6a697b33f8e30dd80a8fff8f8a05 3a57d287dd82efbe9e903a597635932e50765b28 pngload-20220707-git pngload.asd pngload.test.asd
poler http://beta.quicklisp.org/archive/poler/2018-12-10/poler-20181210-git.tgz 6505 9f7588fcb283ff5c56bab084304fc4a3 fbf7235432d08b6d488bd1282ba19dddd9e0db36 poler-20181210-git poler-test.asd poler.asd
policy-cond http://beta.quicklisp.org/archive/policy-cond/2020-04-27/policy-cond-20200427-git.tgz 5976 c62090127d03b788518ac1257f49eda2 a6e5303456d976a67cfe6f05badc513b088664c6 policy-cond-20200427-git policy-cond.asd
polisher http://beta.quicklisp.org/archive/polisher/2021-12-30/polisher-20211230-git.tgz 8088 018a57d2e94b9e8458c29c4e3aad4fdf 3da4faf6d9b74689b39929271db70be44d948d7b polisher-20211230-git polisher.asd polisher.test.asd
polymorphic-functions http://beta.quicklisp.org/archive/polymorphic-functions/2022-11-06/polymorphic-functions-20221106-git.tgz 73156 f8896e21e8bd5e2905cdbb3e724c930e 67aed82e123365e638d8915c8a0a65dd3dfb3e86 polymorphic-functions-20221106-git polymorphic-functions.asd
pooler http://beta.quicklisp.org/archive/pooler/2015-06-08/pooler-20150608-git.tgz 4985 75efc3d397c6962954ec3c37b0f45c5f b118bb296d55bcd7d783a4b52b293a970b46728c pooler-20150608-git pooler.asd
portable-condition-system http://beta.quicklisp.org/archive/portable-condition-system/2021-08-07/portable-condition-system-20210807-git.tgz 52721 649af73ed93e5411e9c3dfdcaf22d2ae 60bcfce550b68c58105a720d81ee8ec27cb8a82a portable-condition-system-20210807-git integration/portable-condition-system.integration.asd portable-condition-system.asd
portable-threads http://beta.quicklisp.org/archive/portable-threads/2021-05-31/portable-threads-20210531-git.tgz 31602 e69804b686166e68385bb710f3bb7e97 fc2cf73edff3456db89d864d20ec0e8fce2e4825 portable-threads-20210531-git portable-threads.asd
portableaserve http://beta.quicklisp.org/archive/portableaserve/2019-08-13/portableaserve-20190813-git.tgz 586259 4cd7af3fbd45693800a823aff55fa442 dfd074e79bfd1d98385f2066a82dacf8b3f98bea portableaserve-20190813-git acl-compat/acl-compat.asd aserve/aserve.asd aserve/htmlgen/htmlgen.asd aserve/webactions/webactions.asd
portal http://beta.quicklisp.org/archive/portal/2021-12-09/portal-20211209-git.tgz 17664 77eba399ed30f9c4d051b9cf7ef21aaf 04b135d1e89771ef31e6f6cb02cf9bd41b270b32 portal-20211209-git portal.asd
positional-lambda http://beta.quicklisp.org/archive/positional-lambda/2012-10-13/positional-lambda-2.0.tgz 7250 1099a5457455b7c570132556073aa21f 7433ee7798c5bdbd6c2edd9869f5173d93178727 positional-lambda-2.0 positional-lambda.asd
posix-shm http://beta.quicklisp.org/archive/posix-shm/2022-11-06/posix-shm-20221106-git.tgz 15492 7e255dabb09076f6bf604597d0c6f6ad 8be2368f5ed6391443d7099c2e9f68b31b3215c2 posix-shm-20221106-git posix-shm.asd
postmodern http://beta.quicklisp.org/archive/postmodern/2022-11-06/postmodern-20221106-git.tgz 582853 aab5fca6439f425fc2155c9838e6ed7e 0226cf4db9f69f5b51f36d11c4e131e25cedaa7a postmodern-20221106-git cl-postgres.asd postmodern.asd s-sql.asd simple-date.asd
postmodern-localtime http://beta.quicklisp.org/archive/postmodern-localtime/2020-06-10/postmodern-localtime-20200610-git.tgz 1165 1af6deb83df625574d7e2e541e1ddd5a 25e8544b5822f362a5f4482c0ded2f06d46550bc postmodern-localtime-20200610-git postmodern-localtime.asd
postmodernity http://beta.quicklisp.org/archive/postmodernity/2017-01-24/postmodernity-20170124-git.tgz 3251 9109aace9c9a906732eb0259a15274e0 380ce87aaceedd6aa00a2d94da9b4dfaa16ddd6a postmodernity-20170124-git postmodernity.asd
postoffice http://beta.quicklisp.org/archive/postoffice/2012-09-09/postoffice-20120909-git.tgz 36931 d09dd023aac099aba49bd3a485179a26 0e6aa7efb53da555f44a8b7caefff3dce1e7eaf3 postoffice-20120909-git postoffice.asd
pounds http://beta.quicklisp.org/archive/pounds/2016-02-08/pounds-20160208-git.tgz 22888 7690a4a5aaca79a60bbb5c49ac9ef1b2 b60ec9318d7017a982e95eae42a2a5c6844da2b7 pounds-20160208-git pounds.asd
pp-toml http://beta.quicklisp.org/archive/pp-toml/2022-11-06/pp-toml-20221106-git.tgz 10962 66d1a6c2cc970f7d7569b22b0fc9aa18 68c9902cfff4e9b68042c018e81e14fa2653114d pp-toml-20221106-git pp-toml-tests.asd pp-toml.asd
ppath http://beta.quicklisp.org/archive/ppath/2018-07-11/ppath-20180711-git.tgz 26911 bcfdda2ff1161721b98c2c1233434429 b93079de943fb4f9cf8ef0a3c2517ce4292b8cdc ppath-20180711-git ppath-test.asd ppath.asd
practical-cl http://beta.quicklisp.org/archive/practical-cl/2018-04-30/practical-cl-20180430-git.tgz 241556 6d0d20024a11897b190d9680fb067d79 462ef8018d44d307ae58197ff03d049ad9a0eff1 practical-cl-20180430-git practicals/Chapter03/pcl-simple-database.asd practicals/Chapter08/pcl-macro-utilities.asd practicals/Chapter09/pcl-test-framework.asd practicals/Chapter15/pcl-pathnames.asd practicals/Chapter23/pcl-spam.asd practicals/Chapter24/pcl-binary-data.asd practicals/Chapter25/pcl-id3v2.asd practicals/Chapter26/pcl-url-function.asd practicals/Chapter27/pcl-mp3-database.asd practicals/Chapter28/pcl-shoutcast.asd practicals/Chapter29/pcl-mp3-browser.asd practicals/Chapter31/pcl-html.asd practicals/practical-cl.asd
prbs http://beta.quicklisp.org/archive/prbs/2018-02-28/prbs-20180228-git.tgz 16327 6baec1bb244961320d1a034a30fdb89a c09a9e8fe05cea4dcc3b4573b33c5f517e4c566b prbs-20180228-git doc/prbs-docs.asd prbs.asd
pretty-function http://beta.quicklisp.org/archive/pretty-function/2013-06-15/pretty-function-20130615-git.tgz 6248 7b6ad93307bc8c8ec585a8199e5e9cb6 3eaf9baa4d31922b3adf8b04005393e7d054b4aa pretty-function-20130615-git pretty-function.asd
primecount http://beta.quicklisp.org/archive/primecount/2020-03-25/primecount-20200325-git.tgz 3066 58cddf7bf57bbf3f97ef4f619daea71c e0a3d5f1e82f5ef5de108dfcc81fb4758bfe6ee7 primecount-20200325-git primecount.asd
print-html http://beta.quicklisp.org/archive/print-html/2018-10-18/print-html-20181018-git.tgz 2917 c9f8962deb792e5dd82c3971bfdf3daa ec23887721f684f8cd6170676d7141df9c3b381b print-html-20181018-git print-html.asd
print-licenses http://beta.quicklisp.org/archive/print-licenses/2022-07-07/print-licenses-20220707-git.tgz 3822 c1b02680f1148d081c5989f0d9417b08 15bbc79e73a3ca71c4f7f7004978017cec144ade print-licenses-20220707-git print-licenses.asd
printv http://beta.quicklisp.org/archive/printv/2021-12-30/printv-20211230-git.tgz 16013 2ca0c88812b49484e30306b2d973abc9 182d927f00580f9f027a1682bbe629ad67a0b57d printv-20211230-git printv.asd
priority-queue http://beta.quicklisp.org/archive/priority-queue/2015-07-09/priority-queue-20150709-git.tgz 2535 5196d0b355b72215228de49eeb0df745 65644f0e3eb8bd23af1ffe64f856bbd9c4d1ac15 priority-queue-20150709-git priority-queue.asd
proc-parse http://beta.quicklisp.org/archive/proc-parse/2019-08-13/proc-parse-20190813-git.tgz 8695 99bdce79943071267c6a877d8de246c5 18fff39d2a228aeb60547154bb09745d2a8769e1 proc-parse-20190813-git proc-parse-test.asd proc-parse.asd
projectured http://beta.quicklisp.org/archive/projectured/2017-12-27/projectured-quicklisp-c3a60e76-git.tgz 3573436 501022101c0211a267b608c4615fdce0 3e002e0bc323ffa8a6495bdd42883027516f69c6 projectured-quicklisp-c3a60e76-git projectured.document.asd projectured.editor.asd projectured.executable.asd projectured.projection.asd projectured.sdl.asd projectured.sdl.test.asd projectured.swank.asd projectured.test.asd
prometheus.cl http://beta.quicklisp.org/archive/prometheus.cl/2020-12-20/prometheus.cl-20201220-git.tgz 26101 c5834e4037e9a987b1f3dea353fe86be a2f6e45e3bbc38947610e4d0dbcd20d66e2da6d2 prometheus.cl-20201220-git prometheus.asd prometheus.collectors.process.asd prometheus.collectors.process.test.asd prometheus.collectors.sbcl.asd prometheus.collectors.sbcl.test.asd prometheus.examples.asd prometheus.exposers.hunchentoot.asd prometheus.exposers.hunchentoot.test.asd prometheus.formats.text.asd prometheus.formats.text.test.asd prometheus.pushgateway.asd prometheus.pushgateway.test.asd prometheus.test.all.asd prometheus.test.asd prometheus.test.support.asd
promise http://beta.quicklisp.org/archive/promise/2021-12-30/promise-20211230-git.tgz 13574 e8c0501d73cde751a5665639779d3f2a ad384ca8b338596f48936842f10bee8a967898e0 promise-20211230-git promise-test.asd promise.asd
prompt-for http://beta.quicklisp.org/archive/prompt-for/2022-07-07/prompt-for-20220707-git.tgz 5290 df68b8f199784e21f552cc81530579e1 7daaaa1c7a8b2a053b1b4d9fa83ba3053624f1c7 prompt-for-20220707-git prompt-for.asd spec/prompt-for.test.asd
protest http://beta.quicklisp.org/archive/protest/2020-12-20/protest-20201220-git.tgz 68187 caee2a3cc32c8fa45170aaafb906697b 5bbbbc08387809f2b3616788dfa0b887432e5a41 protest-20201220-git protest.asd
protobuf http://beta.quicklisp.org/archive/protobuf/2022-03-31/protobuf-20220331-git.tgz 92900 0672e54102a7063ca33e08817bc9d0dd 11db05abee1783e85e396890db0b89d65667cbfd protobuf-20220331-git conformance/protobuf-conformance.asd protobuf.asd varint/varint.asd
prove http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz 877452 85780b65e84c17a78d658364b8c4d11b 1582bc8fb61acc47ab94e7b41072ae4c91fcbad4 prove-20200218-git cl-test-more.asd prove-asdf.asd prove-test.asd prove.asd
pseudonyms http://beta.quicklisp.org/archive/pseudonyms/2020-03-25/pseudonyms-20200325-git.tgz 4086 b768d5c75ba7b417ef894bcd2c3c2b28 bae12df342a5e866b7b458ee0098283900bf1aa5 pseudonyms-20200325-git pseudonyms.asd
psgraph http://beta.quicklisp.org/archive/psgraph/2010-10-06/psgraph-1.2.tgz 8448 df735b2f6c45e14ea18c16650ad8e90d 1cb75fe9886dd39bc7dbdd92c5e4a0b7e229218a psgraph-1.2 psgraph.asd
psychiq http://beta.quicklisp.org/archive/psychiq/2020-09-25/psychiq-20200925-git.tgz 17646 f4a13dcb918491137ad6b396afe50456 3c72aa6c3a39417dd141b1fd311a3558c06ed991 psychiq-20200925-git psychiq-test.asd psychiq.asd
ptester http://beta.quicklisp.org/archive/ptester/2016-09-29/ptester-20160929-git.tgz 12713 938a4366b6608ae5c4a0be9da11a61d4 c32afa4c3f143967eddf4ace14f3e15429610f7f ptester-20160929-git ptester.asd
purgatory http://beta.quicklisp.org/archive/purgatory/2022-07-07/purgatory-20220707-git.tgz 42502 7db575f3629f82c439ef89333388557d 68d09380fcf6cf8d4767f603f6fa762a8a993cef purgatory-20220707-git purgatory-tests.asd purgatory.asd
puri http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz 29178 890c61df1d7204b2d681bf146c43e711 9bfd6d8fea4903f8a4333d2788d9a45a33292098 puri-20201016-git puri.asd
purl http://beta.quicklisp.org/archive/purl/2016-09-29/purl-20160929-git.tgz 32297 ab5d05fcdd2b09d143ebc4e332b4058b 7ce1d37badf30b8386747f26d330b0432d2be4a1 purl-20160929-git purl.asd
pvars http://beta.quicklisp.org/archive/pvars/2021-02-28/pvars-20210228-git.tgz 2000 f4a305664f44d496724d5cc90e21822e 0577e02c256c7555e29f4f2293402ec437630618 pvars-20210228-git pvars.asd
py-configparser http://beta.quicklisp.org/archive/py-configparser/2017-08-30/py-configparser-20170830-svn.tgz 8452 b6a9fc2a9c70760d6683cafe656f9e90 256cf7e56d08aa7021f8c0739f0f6a2912780c1c py-configparser-20170830-svn py-configparser.asd
py4cl http://beta.quicklisp.org/archive/py4cl/2022-07-07/py4cl-20220707-git.tgz 616493 029de49a10fcb001f8e50b3499479b0f 0dee6df9f41940deada17026b8b75483cebd3c22 py4cl-20220707-git py4cl.asd
py4cl2 http://beta.quicklisp.org/archive/py4cl2/2021-12-09/py4cl2-v2.9.0.tgz 876379 50fa7814f232395c541313d1df138bf5 d79face539ecbc8fa89c02ce5b994f27640579cd py4cl2-v2.9.0 py4cl2.asd
pythonic-string-reader http://beta.quicklisp.org/archive/pythonic-string-reader/2018-07-11/pythonic-string-reader-20180711-git.tgz 3594 8156636895b1148fad6e7bcedeb6b556 084f20b11e986f7f186f5f8744ce0e77c2065129 pythonic-string-reader-20180711-git pythonic-string-reader.asd
pzmq http://beta.quicklisp.org/archive/pzmq/2021-05-31/pzmq-20210531-git.tgz 21958 1d3b5223582898476399e164a0c982d2 9a9a01e9695cdd71ca64e2cf3e56bfb5162f563c pzmq-20210531-git pzmq.asd
qbase64 http://beta.quicklisp.org/archive/qbase64/2022-02-20/qbase64-20220220-git.tgz 15720 501aa5fc53a7706ac379ee1ed13642f2 f6107234416cf603573856ebda67fbda4aa0ee79 qbase64-20220220-git qbase64.asd
qbook http://beta.quicklisp.org/archive/qbook/2013-03-12/qbook-20130312-darcs.tgz 12971 6e1cc023c21340d4884da27ce1a1df39 872d11a845287195e88e3fd1d3045a0c471e5698 qbook-20130312-darcs qbook.asd
ql-checkout http://beta.quicklisp.org/archive/ql-checkout/2019-05-21/ql-checkout-20190521-git.tgz 4290 e2b0b29b3829a67a6f88aab932b68e5f c3cf51de9f3c2a6155d838e5645363be4c596dd4 ql-checkout-20190521-git ql-checkout.asd
qlot http://beta.quicklisp.org/archive/qlot/2022-03-31/qlot-20220331-git.tgz 36189 5870b35d10bd13ff527d09f69442acff 13113b4ffde786450bad1278ddd610f23fb43c50 qlot-20220331-git qlot.asd
qmynd http://beta.quicklisp.org/archive/qmynd/2019-07-10/qmynd-20190710-git.tgz 48872 c4a230ca44c5c037664979dfd48985a9 2a43db7117073bc830ad419da96a5e60cb1d2a89 qmynd-20190710-git qmynd.asd tests/qmynd-test.asd
qoi http://beta.quicklisp.org/archive/qoi/2022-07-07/qoi-20220707-git.tgz 3197 d04842521ef0e9610abdccb87b74b8bd e18b150b12cc018f6d7867c6ac0befb15f18604b qoi-20220707-git qoi.asd
qt-libs http://beta.quicklisp.org/archive/qt-libs/2021-05-31/qt-libs-20210531-git.tgz 52711 dd7f9861ca98aec24693681848a98268 a9369ba3a63377d6a612b71ab1ee313fdb8ac69c qt-libs-20210531-git qt-lib-generator.asd qt-libs.asd systems/commonqt.asd systems/phonon.asd systems/qimageblitz.asd systems/qsci.asd systems/qt3support.asd systems/qtcore.asd systems/qtdbus.asd systems/qtdeclarative.asd systems/qtgui.asd systems/qthelp.asd systems/qtnetwork.asd systems/qtopengl.asd systems/qtscript.asd systems/qtsql.asd systems/qtsvg.asd systems/qttest.asd systems/qtuitools.asd systems/qtwebkit.asd systems/qtxml.asd systems/qtxmlpatterns.asd systems/qwt.asd systems/smokebase.asd
qtools http://beta.quicklisp.org/archive/qtools/2020-04-27/qtools-20200427-git.tgz 197043 08c19f0b33c9898c5daf9d858db530b8 500e27aeb057a8fd6a9ecdf77aeb74f6410a02aa qtools-20200427-git examples/evaluator/qtools-evaluator.asd examples/game/qtools-game.asd examples/helloworld/qtools-helloworld.asd examples/melody/qtools-melody.asd examples/opengl/qtools-opengl.asd examples/titter/qtools-titter.asd q+.asd qtools.asd
qtools-ui http://beta.quicklisp.org/archive/qtools-ui/2020-02-18/qtools-ui-20200218-git.tgz 66141 d03693fdcd2f5d7db452565223783beb 0bb39cfd917f51e84ebd6c7743b016e965aafc0b qtools-ui-20200218-git qtools-ui-auto-resizing-textedit.asd qtools-ui-base.asd qtools-ui-bytearray.asd qtools-ui-cell.asd qtools-ui-color-history.asd qtools-ui-color-picker.asd qtools-ui-color-sliders.asd qtools-ui-color-triangle.asd qtools-ui-compass.asd qtools-ui-container.asd qtools-ui-debugger.asd qtools-ui-dialog.asd qtools-ui-dictionary.asd qtools-ui-drag-and-drop.asd qtools-ui-executable.asd qtools-ui-fixed-qtextedit.asd qtools-ui-flow-layout.asd qtools-ui-helpers.asd qtools-ui-imagetools.asd qtools-ui-keychord-editor.asd qtools-ui-layout.asd qtools-ui-listing.asd qtools-ui-notification.asd qtools-ui-options.asd qtools-ui-panels.asd qtools-ui-placeholder-text-edit.asd qtools-ui-plot.asd qtools-ui-progress-bar.asd qtools-ui-repl.asd qtools-ui-slider.asd qtools-ui-spellchecked-text-edit.asd qtools-ui-splitter.asd qtools-ui-svgtools.asd qtools-ui.asd
quad-tree http://beta.quicklisp.org/archive/quad-tree/2022-07-07/quad-tree-20220707-git.tgz 2298 2f7f69077222242d286340cf1e24d84a 35fea9123ad1fd7f82523ad2a8faed2c04fe09ec quad-tree-20220707-git quad-tree.asd
quadtree http://beta.quicklisp.org/archive/quadtree/2015-07-09/quadtree-20150709-git.tgz 3869 50ff5dc28ea35f3073946739537f039d 7961bb58a4a4e50008d5398fbb1ae71380e36248 quadtree-20150709-git quadtree-test.asd quadtree.asd
quantile-estimator.cl http://beta.quicklisp.org/archive/quantile-estimator.cl/2016-08-25/quantile-estimator.cl-20160825-git.tgz 3510 3a28f05e4466c714f712d31cc190992c 30796c8194de9b436e022a35aa5973db986fbd05 quantile-estimator.cl-20160825-git quantile-estimator.asd quantile-estimator.test.asd
quasiquote-2.0 http://beta.quicklisp.org/archive/quasiquote-2.0/2015-05-05/quasiquote-2.0-20150505-git.tgz 8956 7c557e0c10cf7608afa5a20e4a83c778 5f61d74c96a9a863f38ab56c08b5287187bd9ef7 quasiquote-2.0-20150505-git quasiquote-2.0.asd
queen.lisp http://beta.quicklisp.org/archive/queen.lisp/2016-09-29/queen.lisp-20160929-git.tgz 22553 2e7c68441e99d826cfb2c7cb9aa83766 f7988f650dfc560c49226e848de326b9d69da068 queen.lisp-20160929-git queen.asd
query-fs http://beta.quicklisp.org/archive/query-fs/2022-11-06/query-fs-20221106-git.tgz 457337 7b65347c411d4a38148235bc6bf49b59 a32720dde6e37150937c97c4c63242832261fd14 query-fs-20221106-git query-fs.asd
query-repl http://beta.quicklisp.org/archive/query-repl/2022-03-31/query-repl-20220331-git.tgz 9141 368ccf17fd176bf9f40808bacb15dc60 9dfe190ce2c56f2669455c01ddadccfd1a6277b9 query-repl-20220331-git query-repl.asd spec/query-repl.test.asd
queues http://beta.quicklisp.org/archive/queues/2017-01-24/queues-20170124-git.tgz 8748 9b291db09b7385e12515697f1f918e27 3835c55c8a7010b35d4b2ef2e9ce54845ca564bc queues-20170124-git queues.asd queues.priority-cqueue.asd queues.priority-queue.asd queues.simple-cqueue.asd queues.simple-queue.asd
quick-patch http://beta.quicklisp.org/archive/quick-patch/2022-11-06/quick-patch-20221106-git.tgz 10291 a846bbf9d14b3470c9576c2e563de329 37a106882f563e8bdd16c172d78eec5d85ca3be7 quick-patch-20221106-git quick-patch.asd
quickapp http://beta.quicklisp.org/archive/quickapp/2016-08-25/quickapp-20160825-git.tgz 7116 f7c00d1217d7b58f6f1f023668580891 2f4eff6c45eca224463eb0a32eacfd5e34513f0f quickapp-20160825-git quickapp.asd
quicklisp-slime-helper http://beta.quicklisp.org/archive/quicklisp-slime-helper/2015-07-09/quicklisp-slime-helper-20150709-git.tgz 2211 08a86772cfee1a9dc7b1d4a9bb7d371e 6abe815efe3a1b03cb485d4d95329188b1100fe5 quicklisp-slime-helper-20150709-git quicklisp-slime-helper.asd
quicklisp-stats http://beta.quicklisp.org/archive/quicklisp-stats/2021-04-11/quicklisp-stats-20210411-git.tgz 2779 aea4334ca7e8f4a81276fff085a4d1a8 ddba869c5a1bf742afb1a27c70e068ea74cf6796 quicklisp-stats-20210411-git quicklisp-stats.asd
quickproject http://beta.quicklisp.org/archive/quickproject/2019-12-27/quickproject-1.4.1.tgz 6777 1d582d9dc066e0904f716166e448ccb7 eefaabe524fb4113b7b785f623899e417bed7d72 quickproject-1.4.1 quickproject.asd
quicksearch http://beta.quicklisp.org/archive/quicksearch/2017-10-19/quicksearch-20171019-git.tgz 13482 b64e3f756d4edafe270499058b087c26 8984719946dc05f5ad03063265e1fbc1e9986516 quicksearch-20171019-git quicksearch.asd
quickutil http://beta.quicklisp.org/archive/quickutil/2021-08-07/quickutil-20210807-git.tgz 1508477 4713b543b2cc81cfd180ae40bb78d8d3 8cbb1868dae3b8a8846eba4a35efb5f744a429c0 quickutil-20210807-git quickutil-client/quickutil-client-management.asd quickutil-client/quickutil-client.asd quickutil-client/quickutil.asd quickutil-server/quickutil-server.asd quickutil-utilities/quickutil-utilities-test.asd quickutil-utilities/quickutil-utilities.asd
quilc http://beta.quicklisp.org/archive/quilc/2021-12-09/quilc-v1.26.0.tgz 2341004 9902feccf5c96a99bbaf999e11f12638 8837e82842d2433aaf0e3318d6e93d3636489b92 quilc-v1.26.0 boondoggle/boondoggle-tests.asd boondoggle/boondoggle.asd cl-quil-benchmarking.asd cl-quil-tests.asd cl-quil.asd quilc-tests.asd quilc.asd
quri http://beta.quicklisp.org/archive/quri/2022-11-06/quri-20221106-git.tgz 71549 993d698354b40c797b18550ac0fcc24b ae21361a3da48078de8fca74c9346e034e95fecd quri-20221106-git quri-test.asd quri.asd
quux-hunchentoot http://beta.quicklisp.org/archive/quux-hunchentoot/2021-12-30/quux-hunchentoot-20211230-git.tgz 4566 d362b11910f41fdd9ef84cee8d78e3d9 54e98fbc830221484b224ec3260e0680718f1580 quux-hunchentoot-20211230-git quux-hunchentoot.asd
quux-time http://beta.quicklisp.org/archive/quux-time/2015-04-07/quux-time-20150407-git.tgz 34282 f89bd972e19dd2fd5abae2a9e8b143e2 51b24561e194e32110bbb5a6e6be5d98c6daac8c quux-time-20150407-git quux-time.asd
qvm http://beta.quicklisp.org/archive/qvm/2021-06-30/qvm-v1.17.2.tgz 391434 5a183912982de99c0bfa7b98995b7cfd f491a882cac8bac0389cb891b616569265b9a55f qvm-v1.17.2 qvm-app-ng-tests.asd qvm-app-ng.asd qvm-app-tests.asd qvm-app.asd qvm-benchmarks.asd qvm-examples.asd qvm-tests.asd qvm.asd
racer http://beta.quicklisp.org/archive/racer/2019-07-10/racer-20190710-git.tgz 28462787 ecc163e4033836e93aaeb3990052fe3a f27637cb6f310019ad45377016535f15b1cbffdf racer-20190710-git clients/lracer/lracer.asd racer.asd
random http://beta.quicklisp.org/archive/random/2019-10-07/random-20191007-git.tgz 4620 13a609118dd74e217fafd018875b8366 9c3214946a660c5edc558c2f592ff70994c3df65 random-20191007-git acm-random-test.asd acm-random.asd random-test.asd random.asd
random-access-lists http://beta.quicklisp.org/archive/random-access-lists/2012-02-08/random-access-lists-20120208-git.tgz 4903 36e5b00c2556ffda4cc2d6297471d053 7f2fe5a0f6497a98b538bfed7fa0dea7c3c3d8cc random-access-lists-20120208-git random-access-lists.asd
random-sample http://beta.quicklisp.org/archive/random-sample/2021-12-30/random-sample-20211230-git.tgz 3363 72775bdff5ee3bd7afed1e37a319d468 e7da15f940e6e61215357fb1d8bed6c5acf15198 random-sample-20211230-git random-sample.asd
random-state http://beta.quicklisp.org/archive/random-state/2022-11-06/random-state-20221106-git.tgz 17264 e5c0d80f4a416ec295c9a11e584755a1 2377a8648120880391cc12bec383849903071932 random-state-20221106-git random-state-viewer.asd random-state.asd
random-uuid http://beta.quicklisp.org/archive/random-uuid/2022-07-07/random-uuid-20220707-git.tgz 2656 3a1d72c90c6cb2f344ff9ffd8cb4062f 790bf569a91f7fc2c68a84df573187560227f501 random-uuid-20220707-git random-uuid.asd
rate-monotonic http://beta.quicklisp.org/archive/rate-monotonic/2020-03-25/rate-monotonic-20200325-git.tgz 16931 260c267ffe9cb9b81d5eda850b680541 524a7cfec798f4bd8234489eabeed524da199f37 rate-monotonic-20200325-git rate-monotonic.asd rate-monotonic.examples.asd
ratify http://beta.quicklisp.org/archive/ratify/2019-10-07/ratify-20191007-git.tgz 30103 bb3371f343c1cfd75b6cc4ea6f2e7cc1 c4e33d368e883efdb66356afd4cffc0c6593bedf ratify-20191007-git ratify.asd
ratmath http://beta.quicklisp.org/archive/ratmath/2020-02-18/ratmath-20200218-git.tgz 17994 dfc7111393f55ac9c1b3b0ebe1ef08dd 017dd71f6e9e7a6810ea2377663fd3477dece6a9 ratmath-20200218-git ratmath.asd
rcl http://beta.quicklisp.org/archive/rcl/2020-12-20/rcl-20201220-http.tgz 40946 e398fb471f675b98aa45cd5bdc8528d4 780a0712e9e5026a3e12b3bc800b0b9148547c99 rcl-20201220-http rcl.asd
re http://beta.quicklisp.org/archive/re/2021-06-30/re-20210630-git.tgz 8650 957bb9a39cf0e286952fbc9abd911188 dc221562d81b94af4a7f202f55accc26d613128e re-20210630-git re.asd
read-as-string http://beta.quicklisp.org/archive/read-as-string/2022-07-07/read-as-string-20220707-git.tgz 7465 9f5e5104a798bd01242a95e48d17dc73 65ae87fd3b5dc2844b2871f7b5daae93687490b6 read-as-string-20220707-git read-as-string.asd spec/read-as-string.test.asd
read-csv http://beta.quicklisp.org/archive/read-csv/2018-10-18/read-csv-20181018-git.tgz 4924 ef21abc13722ff1ede9f72951bd725af ac27005e51ff658b0b28665fefc260b812032802 read-csv-20181018-git read-csv.asd
read-number http://beta.quicklisp.org/archive/read-number/2022-03-31/read-number-20220331-git.tgz 13933 785d0ba40c2ea4d993275aba5309d26d 8b37c970d40d6c30b950cc7299c974ab6f3e0c30 read-number-20220331-git read-number.asd
reader http://beta.quicklisp.org/archive/reader/2020-12-20/reader-v0.10.0.tgz 8646 4f175d1110f2b5622fdb1a0fe2c42de2 de6be40138a21cfc03067846ca1a767711f89cf3 reader-v0.10.0 reader+swank.asd reader.asd
reader-interception http://beta.quicklisp.org/archive/reader-interception/2015-06-08/reader-interception-20150608-git.tgz 5162 8bb17a9cb708c842cb9cac112bd2d7b7 b8319c2a038be121cf1cc5ac493e876880d52ea2 reader-interception-20150608-git reader-interception-test.asd reader-interception.asd
rectangle-packing http://beta.quicklisp.org/archive/rectangle-packing/2013-06-15/rectangle-packing-20130615-git.tgz 16507 98a4a3e3a1daf65b56475e1f850ca0a7 08ed9778cc20bb058a54e1db28fbbdeb75c929ba rectangle-packing-20130615-git rectangle-packing.asd
recur http://beta.quicklisp.org/archive/recur/2019-03-07/recur-20190307-hg.tgz 1485 c29fa990323309c17e98cc7eadd2b31d edc298a910d5c737937aed72f66f7d484a55485a recur-20190307-hg recur.asd
recursive-regex http://beta.quicklisp.org/archive/recursive-regex/2012-04-07/recursive-regex-20120407-git.tgz 11763 fefa07fe68a4a99338900a7be78129b3 4a09f21c6e6daf510dc1570431ed4ddd40716815 recursive-regex-20120407-git recursive-regex.asd
recursive-restart http://beta.quicklisp.org/archive/recursive-restart/2016-10-31/recursive-restart-20161031-git.tgz 3054 39d5c3ca334229dd5f5111a6f993d8a0 cf91a8a01feb4efbf8ce3d7cd74e34b224a90faf recursive-restart-20161031-git recursive-restart.asd
red-black-tree http://beta.quicklisp.org/archive/red-black-tree/2022-07-07/red-black-tree-20220707-git.tgz 3576 ec7a44b46105b584f7b16af45a21a3f9 77fc93e44a70a4e304a693e8f237abe4f2507ee5 red-black-tree-20220707-git red-black-tree.asd
redirect-stream http://beta.quicklisp.org/archive/redirect-stream/2019-07-10/redirect-stream-20190710-git.tgz 3914 3dbcdaad096f9ba1e308a351fce12744 14dcc7ff3bd776e2b391fa7f74a17b089b975c17 redirect-stream-20190710-git redirect-stream.asd
regex http://beta.quicklisp.org/archive/regex/2012-09-09/regex-20120909-git.tgz 30204 545d10011ea7d33cea0dfcb238acf94b 9ab918df7063e4aac22c3cb0a4776529747cf080 regex-20120909-git regex.asd
regular-type-expression http://beta.quicklisp.org/archive/regular-type-expression/2020-02-18/regular-type-expression-export-to-quicklisp-502a46e2-git.tgz 2734810 6a3a7577be89230e4c2d3c4e64351ea1 bf986266bc4152db470e150638aac0db79b0a8e9 regular-type-expression-export-to-quicklisp-502a46e2-git 2d-array/2d-array-test.asd 2d-array/2d-array.asd adjuvant/adjuvant-test.asd adjuvant/adjuvant.asd cl-robdd/cl-robdd-analysis-test.asd cl-robdd/cl-robdd-analysis.asd cl-robdd/cl-robdd-test.asd cl-robdd/cl-robdd.asd dispatch/dispatch-test.asd dispatch/dispatch.asd lisp-types/lisp-types-analysis.asd lisp-types/lisp-types-test.asd lisp-types/lisp-types.asd ndfa/ndfa-test.asd ndfa/ndfa.asd research.asd rte-regexp/rte-regexp-test.asd rte-regexp/rte-regexp.asd rte/rte-test.asd rte/rte.asd scrutiny/scrutiny-test.asd scrutiny/scrutiny.asd
remote-js http://beta.quicklisp.org/archive/remote-js/2019-07-10/remote-js-20190710-git.tgz 4434 fcc3b2e4201c1ad11ec8575a98bce39e 0a623b75ed970fe8e5f9d5572c4bf1bccbcf3ec5 remote-js-20190710-git remote-js-test.asd remote-js.asd
repl-utilities http://beta.quicklisp.org/archive/repl-utilities/2021-02-28/repl-utilities-20210228-git.tgz 11317 8a0e083369155c2ac67a741733e9e8e9 5a42ac95db63038de5fa574c9d0e593d7f4712ec repl-utilities-20210228-git repl-utilities.asd
replic http://beta.quicklisp.org/archive/replic/2022-11-06/replic-20221106-git.tgz 31026 61e8770d7b2d9cb83b76ed628173ad57 f01eaefab4b3e605c0f9372c4c0ce8c1916917da replic-20221106-git replic-test.asd replic.asd
resignal-bind http://beta.quicklisp.org/archive/resignal-bind/2021-10-20/resignal-bind-20211020-git.tgz 5423 a7dc4a99ab8ed9233edf505095b45eb7 365b63f6f1af9188406624491dfa199f4bf77cea resignal-bind-20211020-git resignal-bind.asd spec/resignal-bind.test.asd
restas http://beta.quicklisp.org/archive/restas/2019-10-08/restas-20191008-git.tgz 182787 ceec9a0482460e2ad32446d43623480b cec4ae81730d0f741cdf3a436750a564de2c9d31 restas-20191008-git docs/restas-doc.asd restas.asd
restas-directory-publisher http://beta.quicklisp.org/archive/restas-directory-publisher/2013-01-28/restas-directory-publisher-20130128-git.tgz 13313 ac714dd7b907eebaa428fc411fce7434 112f0d8f6aa05b4e4a3fbae8131c1dd20f05a1cf restas-directory-publisher-20130128-git restas-directory-publisher.asd
restas.file-publisher http://beta.quicklisp.org/archive/restas.file-publisher/2012-01-07/restas.file-publisher-20120107-git.tgz 1176 74b3636315653b08c83747b8a45796d5 48bd0eb451bc218675ba47a64240d261a8cd5d4f restas.file-publisher-20120107-git restas.file-publisher.asd
restful http://beta.quicklisp.org/archive/restful/2015-06-08/restful-20150608-git.tgz 12311 fb8e34eba9a82fcd8351eb16dd908176 aebeed541ff77427483632265e4f0dda44c62669 restful-20150608-git restful-test.asd restful.asd
restricted-functions http://beta.quicklisp.org/archive/restricted-functions/2019-05-21/restricted-functions-20190521-git.tgz 6700 0ae3b25b8fa92ea9d625cae324ec445f 7e47bc6d54ff68ec0d0e65f34c635a3b6f9d9d10 restricted-functions-20190521-git code/restricted-functions.asd
retrospectiff http://beta.quicklisp.org/archive/retrospectiff/2021-12-09/retrospectiff-20211209-git.tgz 1626750 c2094a8867cda6e93d5d82d7903158f1 80549f493f480069a07467206a54c8c22ed06c72 retrospectiff-20211209-git retrospectiff.asd
reversi http://beta.quicklisp.org/archive/reversi/2020-10-16/reversi-20201016-git.tgz 100397 6d316cc54ccf5938d43165ecea27d26a e17a8c0945af94bf4b2707926aa20be6a030cc42 reversi-20201016-git reversi.asd
rfc2109 http://beta.quicklisp.org/archive/rfc2109/2015-12-18/rfc2109-20151218-darcs.tgz 29102 ca039ac430baaed87f08a1a01e4cfe91 8cfa85913f22053a81c691d8eb8309aa6e9eeeb6 rfc2109-20151218-darcs rfc2109.asd
rfc2388 http://beta.quicklisp.org/archive/rfc2388/2018-08-31/rfc2388-20180831-git.tgz 12522 f57e3c588e5e08210516260e67d69226 b9fce4ee84e60426fc9ef11f1847235b13dd256e rfc2388-20180831-git rfc2388.asd
rfc2388-binary http://beta.quicklisp.org/archive/rfc2388-binary/2017-01-24/rfc2388-binary-20170124-darcs.tgz 98374 0f0e4796ce5b4c0d30aee6f87ecf13d5 4ea6b34d653445314332dce88e4792b8332004f0 rfc2388-binary-20170124-darcs rfc2388-binary.asd
rlc http://beta.quicklisp.org/archive/rlc/2015-09-23/rlc-20150923-git.tgz 3997 b26fd533287f1033a7a2885a780c2318 e9d56b4078c5672498325308ae2898ab9dd9b797 rlc-20150923-git rlc.asd
roan http://beta.quicklisp.org/archive/roan/2020-12-20/roan-20201220-git.tgz 1164621 63579220fdeb48ba8beca3de3d327f72 a2c942c4c6b61cee9bad4f4c809fd85549b38003 roan-20201220-git roan.asd
rock http://beta.quicklisp.org/archive/rock/2015-06-08/rock-20150608-git.tgz 9855 e54b64ba4d201d559355eb6bdb8e9d34 fcbcdd37d9cf8de9ae4c8b392ab7de632f58bdd9 rock-20150608-git rock-test.asd rock-web.asd rock.asd
romreader http://beta.quicklisp.org/archive/romreader/2014-07-13/romreader-20140713-git.tgz 6533 1e7c5f085d2495bd7a131b479b85ca8b 4133137ffba648f72739f0faa56b79b8bb48ec3a romreader-20140713-git romreader.asd
rove http://beta.quicklisp.org/archive/rove/2022-03-31/rove-20220331-git.tgz 16728 94667265d0874409f2cd35bee66ccf37 46a0190905b185c3f251a6b28365d218657566ea rove-20220331-git rove.asd
rpcq http://beta.quicklisp.org/archive/rpcq/2022-07-07/rpcq-v3.10.0.tgz 85557 b2c3f1fb75bec04dd3b0b90022452b76 08c76dccdd0c8da050ce8c7a58864fda0fcaf194 rpcq-v3.10.0 rpcq-tests.asd rpcq.asd
rpm http://beta.quicklisp.org/archive/rpm/2016-04-21/rpm-20160421-git.tgz 4835 3c60f17576cb2c22554fff9b0eec2796 15eb5b24e92715d7e25605acd314702178122486 rpm-20160421-git rpm.asd
rs-colors http://beta.quicklisp.org/archive/rs-colors/2022-03-31/rs-colors-20220331-git.tgz 2144027 6440d7e4391f8a5e78c0832ddbf903de e3e0cdd7d9c2c759f88dc863b9eab7f4b8ad9d8d rs-colors-20220331-git dictionaries/rs-colors-html.asd dictionaries/rs-colors-material-io.asd dictionaries/rs-colors-ral-design.asd dictionaries/rs-colors-ral.asd dictionaries/rs-colors-svg.asd dictionaries/rs-colors-tango.asd dictionaries/rs-colors-x11.asd rs-colors-internal.asd rs-colors.asd
rt http://beta.quicklisp.org/archive/rt/2010-10-06/rt-20101006-git.tgz 10676 94a56c473399572ca835ac91c77c04e5 80643f045a1ff7313d55db64a3f6787236f68eff rt-20101006-git rt.asd
rt-events http://beta.quicklisp.org/archive/rt-events/2016-03-18/rt-events-20160318-git.tgz 5518 c9c0de2cafffd8319bc6f8a9ee9c4908 86aabf4057d784d88d938890ca0273ff1dba31f6 rt-events-20160318-git rt-events.asd rt-events.examples.asd
rtg-math http://beta.quicklisp.org/archive/rtg-math/2019-10-07/rtg-math-release-quicklisp-29fc5b3d-git.tgz 94423 fefa73c6923964666ecc8a8c382df718 2ce1482195edd95a831dd09c37f959277cb1a2e5 rtg-math-release-quicklisp-29fc5b3d-git rtg-math.asd rtg-math.vari.asd
rucksack http://beta.quicklisp.org/archive/rucksack/2015-06-08/rucksack-20150608-git.tgz 111832 e968c9e90632cbba892dae1e2833efe3 3e3ec1762970a3ad7df8d87afdae2bd80ab27af0 rucksack-20150608-git rucksack.asd tests/rucksack-test.asd
rutils http://beta.quicklisp.org/archive/rutils/2022-11-06/rutils-20221106-git.tgz 170456 6e108714e5cd2487c6c5ac133db725ab d25626f3c08c3155a7eb3425de22fd9277f00350 rutils-20221106-git rutils-test.asd rutils.asd rutilsx.asd
ryeboy http://beta.quicklisp.org/archive/ryeboy/2020-10-16/ryeboy-20201016-git.tgz 4100 4e7a440ea9cfd3a09281ed7311f49811 635600ea35309820ec1d938105781337798db7f1 ryeboy-20201016-git ryeboy.asd
s-base64 http://beta.quicklisp.org/archive/s-base64/2013-01-28/s-base64-20130128-git.tgz 7033 9c4220053ea4b18fca7a49f29aae0ee1 70c7fc4ed0762db40bc6e0e71f36f358a2c6cb9a s-base64-20130128-git s-base64.asd
s-dot2 http://beta.quicklisp.org/archive/s-dot2/2018-10-18/s-dot2-20181018-git.tgz 6015 2f0d0948c7ab66c0fb75a761f113b9e9 bb3d07b3bc6c9803b97c65aa3dbc1f69cc187299 s-dot2-20181018-git s-dot2.asd
s-graphviz http://beta.quicklisp.org/archive/s-graphviz/2020-12-20/s-graphviz-20201220-git.tgz 137256 dac9eb8efd927ae8db6a2a7481364cba aa9d786602dcc7372d26a3ea2b89463412b50719 s-graphviz-20201220-git s-graphviz.asd
s-http-client http://beta.quicklisp.org/archive/s-http-client/2020-04-27/s-http-client-20200427-git.tgz 10270 42009b81c887a8de095216e908aa0dfd c0d61d645010c9437a7441e0185f781357249951 s-http-client-20200427-git s-http-client.asd
s-http-server http://beta.quicklisp.org/archive/s-http-server/2020-04-27/s-http-server-20200427-git.tgz 24634 c3c20906113eae9ba786c302917c87d1 ae76e253d983a7d22cb7de8e9dfc379c775b14a9 s-http-server-20200427-git s-http-server.asd
s-sysdeps http://beta.quicklisp.org/archive/s-sysdeps/2021-02-28/s-sysdeps-20210228-git.tgz 4359 25d8c1673457341bf60a20752fe59772 fc391038f42567f711c0480f36745e25d53501ba s-sysdeps-20210228-git s-sysdeps.asd
s-utils http://beta.quicklisp.org/archive/s-utils/2020-04-27/s-utils-20200427-git.tgz 5486 ff731815e83ea9d2bbcd537da8407e69 9afe78191625c511232d84dad8a6f34569e54b36 s-utils-20200427-git s-utils.asd
s-xml http://beta.quicklisp.org/archive/s-xml/2015-06-08/s-xml-20150608-git.tgz 21248 9c31c80f0661777c493fab683f776716 03cb87aacf1c44877a76572510df60c563727125 s-xml-20150608-git s-xml.asd
s-xml-rpc http://beta.quicklisp.org/archive/s-xml-rpc/2019-05-21/s-xml-rpc-20190521-git.tgz 23981 33c268048222002af4d6232d71ee7222 d8b595ab60be528be3848eaf64d3b9a77fc62319 s-xml-rpc-20190521-git s-xml-rpc.asd
safe-queue http://beta.quicklisp.org/archive/safe-queue/2020-03-25/safe-queue-20200325-git.tgz 3521 7ba20fe1ffcef15d659dcfeec6f3ca34 f0ca15987798bc3ef5d13da4146f2a42cb12fe35 safe-queue-20200325-git safe-queue.asd
safe-read http://beta.quicklisp.org/archive/safe-read/2022-02-20/safe-read-20220220-git.tgz 5827 f5daf70c6c6d93c09d8b9a31c847aa0a 6095ee304bb34f8be1bcb7db2b2eab791161fdab safe-read-20220220-git safe-read.asd
safety-params http://beta.quicklisp.org/archive/safety-params/2019-02-02/safety-params-20190202-git.tgz 7110 44bdeb52d69878bf67ecf413613538cb 3380fbb899e4130dbc98475d1803f733245e54e5 safety-params-20190202-git safety-params.asd
salza2 http://beta.quicklisp.org/archive/salza2/2021-10-20/salza2-2.1.tgz 17080 867f3e0543a7e34d1be802062cf4893d 5958988357db20d25099248434f3ae284e6b2ab1 salza2-2.1 salza2.asd
sandalphon.lambda-list http://beta.quicklisp.org/archive/sandalphon.lambda-list/2018-07-11/sandalphon.lambda-list-20180711-git.tgz 11120 6b75d6bcd35d610abb1278547266246f 49223fc82d7af2364aba90b495442be3153b4494 sandalphon.lambda-list-20180711-git sandalphon.lambda-list.asd
sanity-clause http://beta.quicklisp.org/archive/sanity-clause/2021-08-07/sanity-clause-20210807-git.tgz 28595 446ca7128c0b540426000337a790b6c8 db6ea132558fef1f5c74c929a193f9dcf3fbb777 sanity-clause-20210807-git sanity-clause.asd
sapaclisp http://beta.quicklisp.org/archive/sapaclisp/2012-05-20/sapaclisp-1.0a.tgz 141501 5a9d213d0063de0cc1ef9fd3aea811ca 2f3bbe44b16bc0bdc6c29be6f00312e9372f61cb sapaclisp-1.0a sapaclisp.asd
sb-cga http://beta.quicklisp.org/archive/sb-cga/2021-05-31/sb-cga-20210531-git.tgz 34880 2481fcad9d95024147dbb70762217501 320d82156f0d81dc19562c6d5b6cd004bbca774b sb-cga-20210531-git sb-cga.asd
sb-fastcgi http://beta.quicklisp.org/archive/sb-fastcgi/2021-01-24/sb-fastcgi-20210124-git.tgz 4584 eceb82ee932bcbf674899c00240cfa9f 66137ecb2c830632b7b6ea54f4feedf71afafe12 sb-fastcgi-20210124-git sb-fastcgi.asd
sb-vector-io http://beta.quicklisp.org/archive/sb-vector-io/2011-08-29/sb-vector-io-20110829-git.tgz 5263 a57684e11ed481a7c4cf7f2623942e49 15faae433ceb327a16f5bcf29cdcd7728a5c1aca sb-vector-io-20110829-git sb-vector-io.asd
sc-extensions http://beta.quicklisp.org/archive/sc-extensions/2022-07-07/sc-extensions-20220707-git.tgz 8848 37b307b310291ab9591a79d4b1db48fe 93e4f0c14b345198159112c264fa7d2674369b11 sc-extensions-20220707-git sc-extensions.asd
schannel http://beta.quicklisp.org/archive/schannel/2021-12-30/schannel-20211230-git.tgz 21822 4440ad0f8b797a85091c28ca5620fc63 72fd633614649f69a16e0eb6e648789914251db4 schannel-20211230-git schannel.asd
scheduler http://beta.quicklisp.org/archive/scheduler/2022-07-07/scheduler-20220707-git.tgz 11427 603b43d176699f5a4433c6b0433eb666 7f4dce49d8e18e785243b9b36fd46810602453d7 scheduler-20220707-git scheduler.asd
screamer http://beta.quicklisp.org/archive/screamer/2021-08-07/screamer-20210807-git.tgz 953917 221b12fca9e7042e6a8e66fa2330b5c4 d0a4f1fdab543ce45c5628b4418c3d60232efe22 screamer-20210807-git screamer-tests.asd screamer.asd
scriba http://beta.quicklisp.org/archive/scriba/2022-07-07/scriba-20220707-git.tgz 33803 1b8d1d30981d198c1402ca7a0238f253 d718e2c5659857880bfe6b75937ec26da607849b scriba-20220707-git scriba-test.asd scriba.asd
scribble http://beta.quicklisp.org/archive/scribble/2016-06-28/scribble-20160628-git.tgz 15810 976a908f6bbe7ac8516a4916dd6cee20 e1e46a668bfda1cb2848b489176ea6d82d5800d7 scribble-20160628-git scribble.asd
scriptl http://beta.quicklisp.org/archive/scriptl/2018-02-28/scriptl-20180228-git.tgz 125271 37927d71784ccef1cdeb309272416d0a 3f940ab4a12dcbb23f78f2a3d8b33f3aaf454793 scriptl-20180228-git scriptl-examples.asd scriptl-util.asd scriptl.asd
sdl2-game-controller-db http://beta.quicklisp.org/archive/sdl2-game-controller-db/2018-02-28/sdl2-game-controller-db-release-quicklisp-335d2b68-git.tgz 7352 ad3ab5458419a5a259313807c8e0b181 770ccc1def893343b1d3ed5ad511b3537b5c7b02 sdl2-game-controller-db-release-quicklisp-335d2b68-git sdl2-game-controller-db.asd
sdl2kit http://beta.quicklisp.org/archive/sdl2kit/2017-11-30/sdl2kit-20171130-git.tgz 11804 906f93a606d1ff2ed8ed613a3fb2d553 0e077fd40e966e93f505a90a9027fe784dc8aaaf sdl2kit-20171130-git sdl2kit-examples.asd sdl2kit.asd
sealable-metaobjects http://beta.quicklisp.org/archive/sealable-metaobjects/2020-06-10/sealable-metaobjects-20200610-git.tgz 10851 f3107ecfe2f98dfca12df289197e16c4 bded3ef5f75b4b088ad1e7ec7fd0f4069a2974d6 sealable-metaobjects-20200610-git code/sealable-metaobjects.asd
secret-values http://beta.quicklisp.org/archive/secret-values/2020-12-20/secret-values-20201220-git.tgz 2545 37e8da2c18e5f0dd33e32f0045cfc60c 943ee86fbc4959765784fa88e44db59ccd995d9e secret-values-20201220-git secret-values.asd
secure-random http://beta.quicklisp.org/archive/secure-random/2016-02-08/secure-random-20160208-git.tgz 2912 ee57beb30d51da8b3969c27ca52fd0d7 5f5b15e224164c1658ed62532759761ba9c26ccc secure-random-20160208-git secure-random.asd
seedable-rng http://beta.quicklisp.org/archive/seedable-rng/2022-07-07/seedable-rng-20220707-git.tgz 37664 a366ca5a1bfff677e8123029bdb54412 20a0871603b3ac44c29c4015103ada69bc3aeecc seedable-rng-20220707-git seedable-rng.asd
sel http://beta.quicklisp.org/archive/sel/2022-11-06/sel-20221106-git.tgz 1650445 074d4acd10573e7e7d2eee68037d052b b8e138f87c295c10e0ec8b155dfb374dfeb5a9a7 sel-20221106-git software-evolution-library.asd
select http://beta.quicklisp.org/archive/select/2022-11-06/select-20221106-git.tgz 293029 d29f31bf29c65abd55c39a6cd57bbebc 2628aace2fb41be7a99eb746da7c63efe538fbf9 select-20221106-git select.asd
select-file http://beta.quicklisp.org/archive/select-file/2020-04-27/select-file-20200427-git.tgz 11859 0ccf85337a7d8892c379d4d1a673b6d6 41a3c9c35ed07008684eeead063ad6e3e3c81c11 select-file-20200427-git select-file.asd
semantic-spinneret http://beta.quicklisp.org/archive/semantic-spinneret/2017-08-30/semantic-spinneret-20170830-git.tgz 2079 3cdc958d8000f1e26f683aa30f0950cb afeea07a5ef5c41d6d90ba0c7b7dfbb9d9569e15 semantic-spinneret-20170830-git semantic-spinneret.asd
sequence-iterators http://beta.quicklisp.org/archive/sequence-iterators/2013-08-13/sequence-iterators-20130813-darcs.tgz 34899 a6b61a5e9026a03c4978f3721bb17632 7cab8da70f985eb5165aa2145e937a04c605e23c sequence-iterators-20130813-darcs extensible-sequences/extensible-sequences.asd sequence-iterators.asd
serapeum http://beta.quicklisp.org/archive/serapeum/2022-11-06/serapeum-20221106-git.tgz 245534 748b1e09cdd821830fd8880206859296 bb8a5c5cbce434ee5b1b7a041d2c923ccad9a0e8 serapeum-20221106-git serapeum.asd
serializable-object http://beta.quicklisp.org/archive/serializable-object/2019-12-27/serializable-object-20191227-git.tgz 22152 5035427309018750274ef7767cf2b2e7 bbdcb991e44ad56e18b3fc8e4873539b731a937e serializable-object-20191227-git serializable-object.asd serializable-object.test.asd
series http://beta.quicklisp.org/archive/series/2013-11-11/series-20131111-git.tgz 151865 396c160a736ad38829dce1db13a75bcc 6bf27684cdd5fae7ab739d954a72bfde7154bc67 series-20131111-git series.asd
session-token http://beta.quicklisp.org/archive/session-token/2014-11-06/session-token-20141106-git.tgz 3020 5e7727a5a92a8ca9b70304f47b6b52b6 713d1d511e522fe2bd1732e03b088ff062852e8f session-token-20141106-git session-token.asd
sexml http://beta.quicklisp.org/archive/sexml/2014-07-13/sexml-20140713-git.tgz 27508 f71d4ee8da885671be8b779266cd865a f4f482c546f955b9eb4f8c200cc5947528ae6b7e sexml-20140713-git contrib/sexml-objects/sexml-objects.asd sexml.asd
sha1 http://beta.quicklisp.org/archive/sha1/2021-10-20/sha1-20211020-git.tgz 3251 7c911414871884f6ec569ee940701f95 c104a176843797a8668c676011e5a13e8b61b9b6 sha1-20211020-git sha1.asd
sha3 http://beta.quicklisp.org/archive/sha3/2018-02-28/sha3-20180228-git.tgz 17156 26078e9dcb90cc6d6e3174880c4514cb 6ba93591c151ee6b04f0aadfc5f93292ef238527 sha3-20180228-git sha3.asd
shadchen http://beta.quicklisp.org/archive/shadchen/2013-10-03/shadchen-20131003-git.tgz 11298 159f11f77ef2c1c2279e502213a97d43 751e9e27c0d249076ae7a14c275d22f5007c9f69 shadchen-20131003-git shadchen.asd
shadow http://beta.quicklisp.org/archive/shadow/2022-07-07/shadow-20220707-git.tgz 15644 cba887b8ada64862384f201cca06192c 8bf568a9878e0cc9c141b234d0631761ad2d9b64 shadow-20220707-git shadow.asd
shared-preferences http://beta.quicklisp.org/archive/shared-preferences/2021-02-28/shared-preferences_1.1.1.tgz 4890 a7e009387968212768f9dec2f85c6f3f 3a998aa794ea3693470b07664285aa9979bf59cf shared-preferences_1.1.1 shared-preferences.asd tests/shared-preferences_tests.asd
shasht http://beta.quicklisp.org/archive/shasht/2022-11-06/shasht-20221106-git.tgz 45542 e820c0c610963f633ede4b2cdaac99c4 0b966982ed7a4708d840b81e67617073c4701b1e shasht-20221106-git shasht.asd
sheeple http://beta.quicklisp.org/archive/sheeple/2021-01-24/sheeple-20210124-git.tgz 623272 024ac85e5aa4741320f8a36e4c6bae75 3cd854d5141acf61a0a8abb952d88a8b78336e74 sheeple-20210124-git sheeple.asd
shellpool http://beta.quicklisp.org/archive/shellpool/2020-09-25/shellpool-20200925-git.tgz 25821 b6be45de2b2c4c6b217f91fce8e5e31a 717b1553825dcdb563c6a0b301b7c45082a4903e shellpool-20200925-git shellpool.asd
shelly http://beta.quicklisp.org/archive/shelly/2014-11-06/shelly-20141106-git.tgz 18127 824938aaaac93602dc927a9734aa1581 2dc9eff9949e91277a0db6376a431b6992681d4b shelly-20141106-git shelly-test.asd shelly.asd
shop3 http://beta.quicklisp.org/archive/shop3/2022-11-06/shop3-20221106-git.tgz 9604737 b721b77c19e23a903cf689d9266e14dc 748680d87c04f2538583f2a95129f944b26e0fb9 shop3-20221106-git shop3/examples/rovers/strips/rovers-problem-translator.asd shop3/shop3-theorem-prover.api/shop3-thmpr-api.asd shop3/shop3.asd
should-test http://beta.quicklisp.org/archive/should-test/2019-10-07/should-test-20191007-git.tgz 7618 f27c9a9c25be4f67204f7c3dccde755f 32aeafca31add71fa61077717e5e5e932033f85f should-test-20191007-git should-test.asd
shuffletron http://beta.quicklisp.org/archive/shuffletron/2018-10-18/shuffletron-20181018-git.tgz 125912 ffa1e84964f41af31bbb853d0b0776a9 7a8f2aaf66cd8978094dacd5e92242dc859deca7 shuffletron-20181018-git shuffletron.asd
simple-actors http://beta.quicklisp.org/archive/simple-actors/2020-09-25/simple-actors-20200925-git.tgz 5277 851e0b289705bf2dd14c7cdb6b58cc08 44858a7ff006db2384d5f6a696dc33c55384f952 simple-actors-20200925-git simple-actors.asd
simple-config http://beta.quicklisp.org/archive/simple-config/2022-07-07/simple-config-20220707-git.tgz 2857 c2f2779efb3333d50944c5f42b6f1845 6a8ee5588b2201c0dada6d4baee14aaae6ad69cc simple-config-20220707-git simple-config-test.asd simple-config.asd
simple-currency http://beta.quicklisp.org/archive/simple-currency/2017-11-30/simple-currency-20171130-git.tgz 12557 71ea0f64c63b4287fc56ece336e08ef9 aa40c0d344e0c9c4b20583d8df86887e55081b2b simple-currency-20171130-git simple-currency.asd
simple-date-time http://beta.quicklisp.org/archive/simple-date-time/2016-04-21/simple-date-time-20160421-git.tgz 5688 a5b1e4af539646723dafacbc8cf732a0 74ea55a0c7d77d7b967b3ad94f9f67137c9cd01e simple-date-time-20160421-git simple-date-time.asd
simple-finalizer http://beta.quicklisp.org/archive/simple-finalizer/2010-10-06/simple-finalizer-20101006-git.tgz 3415 fcc7c3966af77de524e6f24bb9dc1c94 6ac4c1cb19186e78e445885f86da20ba99d868bb simple-finalizer-20101006-git simple-finalizer.asd
simple-flow-dispatcher http://beta.quicklisp.org/archive/simple-flow-dispatcher/2020-10-16/simple-flow-dispatcher-stable-git.tgz 2471 cfbedd68986d9a7b04d913b69616ba88 78c087d2cff43976da25fc4d6cd351b4cbad02ec simple-flow-dispatcher-stable-git simple-flow-dispatcher.asd
simple-guess http://beta.quicklisp.org/archive/simple-guess/2020-09-25/simple-guess_1.0.tgz 9079 13d8551889e77b29188b93bef7f70e0b 450ee24a2c5661ba41e1f33a431071a4a9130575 simple-guess_1.0 simple-guess.asd tests/simple-guess_tests.asd
simple-inferiors http://beta.quicklisp.org/archive/simple-inferiors/2020-03-25/simple-inferiors-20200325-git.tgz 9622 f90ae807c10d5b3c4b9eef1134a537c8 702bd4d3b2964b5d412c1d38fb594d2349984eb6 simple-inferiors-20200325-git simple-inferiors.asd
simple-neural-network http://beta.quicklisp.org/archive/simple-neural-network/2022-11-06/simple-neural-network-20221106-git.tgz 11620556 3ef4ccbb7061be491cdd52f5f82eeb9c 612d0c1b3e9c506f86dd104bdf42fcb8ca4bba0d simple-neural-network-20221106-git simple-neural-network.asd
simple-parallel-tasks http://beta.quicklisp.org/archive/simple-parallel-tasks/2020-12-20/simple-parallel-tasks-20201220-git.tgz 14403 24d4c346d6e175d339ce6f0ea5040274 60ea356bc11a7875aad2023d92e452a1bed8ec07 simple-parallel-tasks-20201220-git simple-parallel-tasks-tests.asd simple-parallel-tasks.asd
simple-rgb http://beta.quicklisp.org/archive/simple-rgb/2019-05-21/simple-rgb-20190521-git.tgz 5464 8afe42c3bb2bec023cfae77a8153c668 2573e45d315e8fe7a0b30f90bd5bb9624044cdb5 simple-rgb-20190521-git simple-rgb.asd
simple-routes http://beta.quicklisp.org/archive/simple-routes/2018-02-28/simple-routes-20180228-git.tgz 6209 95b881171c381674a275da21692442f2 06b1a640d86490ed1e346b2a37306e4a8c7a66f2 simple-routes-20180228-git simple-routes.asd
simple-tasks http://beta.quicklisp.org/archive/simple-tasks/2019-07-10/simple-tasks-20190710-git.tgz 12567 8e88a9a762bc8691f92217d256baa55e 3fdcc5d1debf45d1480f31ce5f7de206ff6aeb87 simple-tasks-20190710-git simple-tasks.asd
simplet http://beta.quicklisp.org/archive/simplet/2019-12-27/simplet-20191227-git.tgz 16303 9fa3343c7a0b9f6f7f43d8b4ed706d98 bf0ee7b1a8770cc028a66ffd6da9770ab6492a3a simplet-20191227-git simplet-asdf.asd simplet.asd
simplified-types http://beta.quicklisp.org/archive/simplified-types/2019-08-13/simplified-types-20190813-git.tgz 6647 c3666e2faf2aed0ec040912db0a91285 c89aa23f3c54e114a3c8de9f3b8254d128bdf7f3 simplified-types-20190813-git code/simplified-types.asd test-suite/simplified-types-test-suite.asd
simpsamp http://beta.quicklisp.org/archive/simpsamp/2010-10-06/simpsamp-0.1.tgz 44485 afd8bdfae4b4f0924839753086bab0bf 38b802cbd0a7855ff101020e71ee2e9fd7927316 simpsamp-0.1 simpsamp.asd
single-threaded-ccl http://beta.quicklisp.org/archive/single-threaded-ccl/2015-06-08/single-threaded-ccl-20150608-git.tgz 2611 fa4c2cf5223e2c57e1b3352edeecca0c 3f7bedd0e7741ac4503bd09a6a84da5921e62b81 single-threaded-ccl-20150608-git single-threaded-ccl.asd
sip-hash http://beta.quicklisp.org/archive/sip-hash/2020-06-10/sip-hash-20200610-git.tgz 5225 a2f874af975545019615435c3b8babd2 c450b0b869d4f49ce15e01fdc8be8d46d3619b44 sip-hash-20200610-git sip-hash.asd
skeleton-creator http://beta.quicklisp.org/archive/skeleton-creator/2019-12-27/skeleton-creator-20191227-git.tgz 42572 ca2c99e3eb2951f96db1190da7ed3c15 68ef28b145fe342fbc69df5b67d300f23733fea4 skeleton-creator-20191227-git skeleton-creator.asd
sketch http://beta.quicklisp.org/archive/sketch/2022-11-06/sketch-20221106-git.tgz 1116766 16efc38b20aaf8ad9fc7406babf7e484 a165350a926b5f1b68e17947179f92eba5dd8507 sketch-20221106-git sketch-examples.asd sketch.asd
skippy http://beta.quicklisp.org/archive/skippy/2015-04-07/skippy-1.3.12.tgz 31965 c64deda635cd8b93768ff837c3b66a72 0a9255fa75a12a7c2f74db9ad584abe68d66a538 skippy-1.3.12 skippy.asd
skippy-renderer http://beta.quicklisp.org/archive/skippy-renderer/2022-11-06/skippy-renderer-20221106-git.tgz 2565 f4d37a207c7fec3c72016e0d3b02ff66 29e7144057affb78a8b932c73e16fb20c86aef21 skippy-renderer-20221106-git skippy-renderer.asd
skitter http://beta.quicklisp.org/archive/skitter/2018-02-28/skitter-release-quicklisp-620772ae-git.tgz 21551 d9148bdb15605412b813b955cc9fb46b 984a7e9102c2fc65635cec373b3944f884e65a03 skitter-release-quicklisp-620772ae-git skitter.asd skitter.glop.asd skitter.sdl2.asd
slack-client http://beta.quicklisp.org/archive/slack-client/2016-08-25/slack-client-20160825-git.tgz 7752 245f64f7188363f1eabbb4b8a2e9c572 c500065dbbd1bf63fc37ec82114d0f76ebc9d906 slack-client-20160825-git slack-client-test.asd slack-client.asd
slime http://beta.quicklisp.org/archive/slime/2022-02-20/slime-v2.27.tgz 823006 fa228382eae3cb59451d41d54264f115 931e279911a4b680e1dfa9116c5967f35aea2233 slime-v2.27 swank.asd
slite http://beta.quicklisp.org/archive/slite/2022-11-06/slite-20221106-git.tgz 13391 f8a0a9d8047dd5d09559d46c96f40612 abfe4612a7aced4d0de4a55ec4922fdd5cafd72a slite-20221106-git slite.asd
slk-581 http://beta.quicklisp.org/archive/slk-581/2019-01-07/slk-581-20190107-git.tgz 4848 d90326b00b92d657b6424002dee00a56 f367c37a8378bddf0810f8fc91a87cbae39a4097 slk-581-20190107-git eclecticse.slk-581.asd
slot-extra-options http://beta.quicklisp.org/archive/slot-extra-options/2021-04-11/slot-extra-options-20210411-git.tgz 25603 87d6dbf73502fca06359c4c4ba07cbd6 4510460f96e02cf02350238eb4c9c10e3ee9aa42 slot-extra-options-20210411-git slot-extra-options-tests.asd slot-extra-options.asd
slot-map http://beta.quicklisp.org/archive/slot-map/2022-07-07/slot-map-20220707-git.tgz 2686 930e19abbfb2545ce1b2ba846a900f34 935a2e9e788df2e84677ada8fa15868a93a86065 slot-map-20220707-git slot-map.asd
sly http://beta.quicklisp.org/archive/sly/2022-11-06/sly-20221106-git.tgz 1835454 364c572099be86e053e7d2d28fc57df3 dd4c71959384afb4998b37aacf83e12d59cb2dde sly-20221106-git slynk/slynk.asd
smackjack http://beta.quicklisp.org/archive/smackjack/2018-02-28/smackjack-20180228-git.tgz 17449 398e790adbd5c3d1c85d211d8e119990 9de59527f4fa97c9c09aaaa448978fdc9d3e4ac7 smackjack-20180228-git demo/smackjack-demo.asd smackjack.asd
smart-buffer http://beta.quicklisp.org/archive/smart-buffer/2021-10-20/smart-buffer-20211020-git.tgz 3382 d09d02788667d987b3988b6de09d09c3 6c240b92d649a3cb3ca138bbc638cafb67bf74c3 smart-buffer-20211020-git smart-buffer-test.asd smart-buffer.asd
smug http://beta.quicklisp.org/archive/smug/2021-12-30/smug-20211230-git.tgz 77473 8661c0d2306a06f0df4bcfe94b48ab7e 77e38fd3add5982edc83a82bc33766f900fab2a1 smug-20211230-git smug.asd
snakes http://beta.quicklisp.org/archive/snakes/2022-11-06/snakes-20221106-git.tgz 16983 d8cd4752b7a6f34218a2461da31d0ae8 6a10fd3b7a54203b6c14ef38b61de40da24ee031 snakes-20221106-git snakes.asd
snappy http://beta.quicklisp.org/archive/snappy/2021-12-09/snappy-20211209-git.tgz 1341585 b9069ecaea208b32d4c959ee87b3fa79 e4a32502587dad72893f88c16d5add64f0773236 snappy-20211209-git snappy.asd
snark http://beta.quicklisp.org/archive/snark/2016-04-21/snark-20160421-git.tgz 275436 b7ee5cb5350f5c675359022c10fc6bb9 b265505c5c331237e1fffbb0aa19fa68ff581cee snark-20160421-git snark-agenda.asd snark-auxiliary-packages.asd snark-deque.asd snark-dpll.asd snark-examples.asd snark-feature.asd snark-implementation.asd snark-infix-reader.asd snark-lisp.asd snark-loads.asd snark-numbering.asd snark-pkg.asd snark-sparse-array.asd snark.asd
sndfile-blob http://beta.quicklisp.org/archive/sndfile-blob/2020-10-16/sndfile-blob-stable-git.tgz 4974837 17379c194e68dd5cf1706b9946c89e35 c75ff2a3ea3aa7aa8a133e5703d2a06901fdfd5f sndfile-blob-stable-git sndfile-blob.asd
snmp http://beta.quicklisp.org/archive/snmp/2016-10-31/snmp-6.1.tgz 4454924 9ea185bf039906911b5f48b73a43c31f 826501f7973e77cd5e2cb19a7ce79d3cb2ecdf1d snmp-6.1 snmp-server.asd snmp-test.asd snmp-ui.asd snmp.asd
snooze http://beta.quicklisp.org/archive/snooze/2021-08-07/snooze-20210807-git.tgz 36375 a215308d9e9c20f9587ea448363b712b e9015553843dccad51f3865f7abec64f4940cf42 snooze-20210807-git snooze.asd
softdrink http://beta.quicklisp.org/archive/softdrink/2020-04-27/softdrink-20200427-git.tgz 5703 fe546b6fa74522959df95606dbe90c5a ea18a1389f6583ddcb6b9d3e817a00b0f7ad85b9 softdrink-20200427-git softdrink.asd
solid-engine http://beta.quicklisp.org/archive/solid-engine/2019-05-21/solid-engine-20190521-git.tgz 6543 f666e1d94dd1a915ce8c680d43ddbf02 a8f3345f2690c751b2df8522c9ad200db016960f solid-engine-20190521-git solid-engine.asd
soundex http://beta.quicklisp.org/archive/soundex/2010-10-06/soundex-1.0.tgz 1652 247f7c15b49b230100d37bbc3964bd10 8515dcfcd3bf21025931ca0837e9fe83c2622012 soundex-1.0 soundex.asd
south http://beta.quicklisp.org/archive/south/2019-07-10/south-20190710-git.tgz 20288 5635201c1fe341b9e75f1c0ea97e4e33 77c9ede6f2025cc776071555e2fc2844fce08650 south-20190710-git south.asd
sparse-set http://beta.quicklisp.org/archive/sparse-set/2022-07-07/sparse-set-20220707-git.tgz 1988 2607221d5f97ad8f986761d82e22f493 908dd185d0d07fc40372efb0bdba6f11d89960ab sparse-set-20220707-git sparse-set.asd
spatial-trees http://beta.quicklisp.org/archive/spatial-trees/2014-08-26/spatial-trees-20140826-git.tgz 21925 2772b963aae5c4d06fff83c22e5c8aa9 5038860caf1e9687de757b3158f9df3086a4d54e spatial-trees-20140826-git spatial-trees.asd spatial-trees.nns.asd spatial-trees.nns.test.asd spatial-trees.test.asd
special-functions http://beta.quicklisp.org/archive/special-functions/2022-11-06/special-functions-20221106-git.tgz 678075 7cf92610d27103e7e38f6e285f1296d7 31c0dd2f65c270feb13d8c2ad9c29dc9f81ea776 special-functions-20221106-git special-functions.asd
specialization-store http://beta.quicklisp.org/archive/specialization-store/2020-06-10/specialization-store-v0.0.5.tgz 64599 d00584daca8e0b9d2535b68a3115d1f9 2929bf40e540306eb990743c4c2b1f64c4944df1 specialization-store-v0.0.5 specialization-store-features.asd specialization-store-tests.asd specialization-store.asd
specialized-function http://beta.quicklisp.org/archive/specialized-function/2021-05-31/specialized-function-20210531-git.tgz 101230 9690bc5e2a9eadd42f5c9b7c21630bb3 38013b2d082293c187d03aeca9a5ed5200773702 specialized-function-20210531-git specialized-function.asd specialized-function.test.asd
speechless http://beta.quicklisp.org/archive/speechless/2022-11-06/speechless-20221106-git.tgz 43622 1cb6834ef63a4156cb3954c8a8f98bc5 0d3e8b659ef4e8d6996cee467368fa56890b4566 speechless-20221106-git speechless.asd
spell http://beta.quicklisp.org/archive/spell/2019-03-07/spell-20190307-git.tgz 3643983 f765650ae77e3aa237817ea9d0edf292 b8280c38fd4e628358ffc445d233b4c2a55c1f36 spell-20190307-git spell.asd
spellcheck http://beta.quicklisp.org/archive/spellcheck/2013-10-03/spellcheck-20131003-git.tgz 2375587 1633f18983bbb368192d1355f3f4f13e f6de93b47beda9d56e14184826bb8b49e10cb789 spellcheck-20131003-git spellcheck.asd
spinneret http://beta.quicklisp.org/archive/spinneret/2022-11-06/spinneret-20221106-git.tgz 28978 7c98850c388698fede86ef96b9841ef2 656818297c6de087bc33bff31edd2cf13a929d95 spinneret-20221106-git spinneret.asd
split-sequence http://beta.quicklisp.org/archive/split-sequence/2021-05-31/split-sequence-v2.0.1.tgz 11705 871be321b4dbca0a1f958927e9173795 fe250d09a3d2b24a0459bebef9ccf401a4733475 split-sequence-v2.0.1 split-sequence.asd
sprint-stars http://beta.quicklisp.org/archive/sprint-stars/2018-08-31/sprint-stars-20180831-git.tgz 1517 db7adeef5208184377f65388661f7ed2 a9de0cfd9e556c34cd2807084fc6ad2e2328a54f sprint-stars-20180831-git stars.asd
srfi-1 http://beta.quicklisp.org/archive/srfi-1/2020-02-18/srfi-1-20200218-git.tgz 17608 e71d27ef564477835be544777d06c3f4 2e8c613d82cb640be609d79df5049b7d84602819 srfi-1-20200218-git srfi-1.asd
srfi-23 http://beta.quicklisp.org/archive/srfi-23/2020-02-18/srfi-23-20200218-git.tgz 1510 8961c102b6d10469c8c73eea590c53fc 8bc69556d6a08b506c8bb21cd64501a25968ad04 srfi-23-20200218-git srfi-23.asd
srfi-6 http://beta.quicklisp.org/archive/srfi-6/2020-02-18/srfi-6-20200218-git.tgz 1556 e9ac54acc1292f6b3174b393e1699eb0 d85e3050e9d34f085967d9b86e7eaf8b0cf1aec7 srfi-6-20200218-git srfi-6.asd
srfi-98 http://beta.quicklisp.org/archive/srfi-98/2020-02-18/srfi-98-20200218-git.tgz 2241 bcd40c30f56cd5e9bf166765db5f920a 805ca9496c161381bb27c38cea866b96ea4786a5 srfi-98-20200218-git srfi-98.asd
st-json http://beta.quicklisp.org/archive/st-json/2021-06-30/st-json-20210630-git.tgz 7916 0297580a888db434426152d4f5dcf786 36fe247ac59fce5ba3edbe8c19676ce182d72b6d st-json-20210630-git st-json.asd
staple http://beta.quicklisp.org/archive/staple/2022-11-06/staple-20221106-git.tgz 99493 b3046e66e4204310e2bcee8707c2ab27 30f7bdb7d296f7dd5325f01d555e8160c25b97f1 staple-20221106-git parser/staple-code-parser.asd server/staple-server.asd staple-markdown.asd staple-markless.asd staple-package-recording.asd staple-restructured-text.asd staple.asd
static-dispatch http://beta.quicklisp.org/archive/static-dispatch/2021-12-09/static-dispatch-20211209-git.tgz 37618 f74cb2bd29ef9cfe966f470c7f63420f 2b0c68b3fc79a57dd54cada8c25f5bdf58c44f79 static-dispatch-20211209-git static-dispatch.asd
static-vectors http://beta.quicklisp.org/archive/static-vectors/2021-06-30/static-vectors-v1.8.9.tgz 6982 f14b819c0d55e7fbd28e9b4a0bb3bfc9 baf9cd392bc3f9f61a6e2c35419348f38c8f1847 static-vectors-v1.8.9 static-vectors.asd
statistics http://beta.quicklisp.org/archive/statistics/2022-11-06/statistics-20221106-git.tgz 405695 dcc23dd8d5c6768dfe35381d7336e2f5 99a419bbbffa95952285d7aac59471f7f8af746d statistics-20221106-git statistics.asd
stealth-mixin http://beta.quicklisp.org/archive/stealth-mixin/2021-10-20/stealth-mixin-20211020-git.tgz 2240 2651e2de91ff06c25159ec322fa1ce86 cb646c7b0644cdf7692250ea155ccdf010a608aa stealth-mixin-20211020-git stealth-mixin.asd
stefil http://beta.quicklisp.org/archive/stefil/2018-12-10/stefil-20181210-git.tgz 18041 3418bf358366748593f65e4b6e1bb8cf f974b02c814ebaaa804f2ecf4c86b0a18abfe6b2 stefil-20181210-git stefil.asd
stefil- http://beta.quicklisp.org/archive/stefil-/2021-12-09/stefil--20211209-git.tgz 5441 f08c80a8739f7279a83a2e6a3de7d448 9827274a32ae7485132eb2c14f6627843a789ea4 stefil--20211209-git stefil+.asd
stem http://beta.quicklisp.org/archive/stem/2015-06-08/stem-20150608-git.tgz 116071 0dc7713fb0412a4d116304960410cdd7 2eecde21d5d4c35d095bc83b2dd26b55bf8d461e stem-20150608-git stem.asd
stepster http://beta.quicklisp.org/archive/stepster/2022-11-06/stepster-20221106-git.tgz 6159 c5a077f7c48cf8be844423cfd5746e1e a151dfa291b09ff86538fcbf9890cb76c9e56ec8 stepster-20221106-git stepster.asd
stl http://beta.quicklisp.org/archive/stl/2017-10-19/stl-20171019-git.tgz 3089 01a69ac8892b8f4a4bb97c57cf4a9da7 90d1d6084da63bf66ecf50ebf2f84d28531d10b4 stl-20171019-git stl.asd
stmx http://beta.quicklisp.org/archive/stmx/2020-12-20/stmx-stable-49eef1d5-git.tgz 363917 411ecb277dca0a62c5df713234c4ed14 622c26024b49fcf08afe0eb97bb6acef2d780cba stmx-stable-49eef1d5-git stmx.asd stmx.test.asd
strict-function http://beta.quicklisp.org/archive/strict-function/2021-10-20/strict-function-20211020-git.tgz 6241 d3808d9976ecc7b9883d2330322da0ee 120a6689f530972c8f88d77464fc37a29b678a49 strict-function-20211020-git strict-function.asd
string-case http://beta.quicklisp.org/archive/string-case/2018-07-11/string-case-20180711-git.tgz 9081 145c4e13f1e90a070b0a95ca979a9680 ff3958a84d23a5b9e743fbf30726a1d9b6c0fbfd string-case-20180711-git string-case.asd
string-escape http://beta.quicklisp.org/archive/string-escape/2015-04-07/string-escape-20150407-http.tgz 15485 8e2acbd7ce3914258979b87a0284a4a1 1d9841f3e851d744c21af85156651eba4aa322d6 string-escape-20150407-http string-escape.asd
stripe http://beta.quicklisp.org/archive/stripe/2022-07-07/stripe-20220707-git.tgz 11600 debcce472b50ea3516dbee414c69b521 80cd9481490fbc2612408c349df0960e27d43085 stripe-20220707-git stripe.asd
stripe-against-the-modern-world http://beta.quicklisp.org/archive/stripe-against-the-modern-world/2022-11-06/stripe-against-the-modern-world-20221106-git.tgz 10365 b64aea9ac478fab947692c146f02764e b3c4f65857beef809d36a78d091b3faf4bf6b6e5 stripe-against-the-modern-world-20221106-git stripe-against-the-modern-world.asd
structure-ext http://beta.quicklisp.org/archive/structure-ext/2021-12-09/structure-ext-20211209-git.tgz 9324 3da78b5c429c8a137198a603dee03259 7530aaada37f7211d7390674c1cb5bfb9e7a741e structure-ext-20211209-git accessors/spec/structure-ext.left-arrow-accessors.test.asd accessors/structure-ext.left-arrow-accessors.asd as-class/spec/structure-ext.as-class.test.asd as-class/structure-ext.as-class.asd make-instance/spec/structure-ext.make-instance.test.asd make-instance/structure-ext.make-instance.asd structure-ext.asd
structy-defclass http://beta.quicklisp.org/archive/structy-defclass/2017-06-30/structy-defclass-20170630-git.tgz 2769 ae666e7951c4137242d95fff9ca6c31e df7f719fa42dc7d3115ed1e0e14cd289eb9f7cce structy-defclass-20170630-git structy-defclass.asd
studio-client http://beta.quicklisp.org/archive/studio-client/2021-02-28/studio-client-20210228-git.tgz 8803 5daaad861363d121e1f3d8fa2c6675ee f7af497cb1cea04306ee0b93e38ed8dd48e75d93 studio-client-20210228-git studio-client.asd
stumpwm http://beta.quicklisp.org/archive/stumpwm/2022-11-06/stumpwm-20221106-git.tgz 272486 fd4731e09b82e3e31785622d65ce76e7 0b5c1edd2ad941079401bf9e5e4629c9399f57cc stumpwm-20221106-git stumpwm-tests.asd stumpwm.asd
stumpwm-dynamic-float http://beta.quicklisp.org/archive/stumpwm-dynamic-float/2022-11-06/stumpwm-dynamic-float-20221106-git.tgz 9077 cd433cf1530e5d304a201509cf5ad09e f1343eb5e2f33ff6bf4fe3e1784cb49852dcf774 stumpwm-dynamic-float-20221106-git stumpwm-dynamic-float.asd
stumpwm-sndioctl http://beta.quicklisp.org/archive/stumpwm-sndioctl/2021-05-31/stumpwm-sndioctl-20210531-git.tgz 2044 f6725d06e5dc151c77b3532d1f08ac1b 0e83a033859cc0932ec34b4cf5ea3f41967ff0ce stumpwm-sndioctl-20210531-git stumpwm-sndioctl.asd
sucle http://beta.quicklisp.org/archive/sucle/2020-04-27/sucle-20200427-git.tgz 447331 b771e797fbee7a5b051b160ac20f3b12 fbbbe5535b2c1ae59e364207f4225875c756c8eb sucle-20200427-git src/aabbcc/aabbcc.asd src/application/application.asd src/camera-matrix/camera-matrix.asd src/character-modifier-bits/character-modifier-bits.asd src/control/control.asd src/crud/crud.asd src/deflazy/deflazy.asd src/fps-independent-timestep/fps-independent-timestep.asd src/image-utility/image-utility.asd src/lem-opengl/lem-opengl.asd src/ncurses-clone-for-lem/ncurses-clone-for-lem.asd src/nsb-cga/nsb-cga.asd src/opengl/glhelp.asd src/quads/quads.asd src/scratch-buffer/scratch-buffer.asd src/sucle-multiprocessing/sucle-multiprocessing.asd src/sucle-serialize/sucle-serialize.asd src/sucle/sucle.asd src/text-subsystem/doc/text-subsystem-generate-font.asd src/text-subsystem/text-subsystem.asd src/uncommon-lisp/uncommon-lisp.asd src/window/window.asd temp/sucle-temp.asd test/sucle-test.asd
swank-client http://beta.quicklisp.org/archive/swank-client/2020-12-20/swank-client-20201220-git.tgz 15985 5e2970dc23cb9f1b62198881b088473c 64d4f99747e6a40843ccc33957dadeb55732c252 swank-client-20201220-git swank-client.asd
swank-crew http://beta.quicklisp.org/archive/swank-crew/2020-06-10/swank-crew-20200610-git.tgz 15858 1b8e5fcdd1b45564eb91069e6111aaaf 24e502723630130359ad569cd5bba214c7c0c1de swank-crew-20200610-git swank-crew.asd
swank-protocol http://beta.quicklisp.org/archive/swank-protocol/2021-10-20/swank-protocol-20211020-git.tgz 7679 c4511a55390efe63549cca9be8c6630c efb59a56e63ac6129f5250a7430fcef4f2d89da8 swank-protocol-20211020-git swank-protocol.asd
swank.live http://beta.quicklisp.org/archive/swank.live/2016-02-08/swank.live-20160208-git.tgz 1754 0cfd0cc920b37a27359244797dfd8817 0e98e9c945773a2f6e8e79688081c942a3327f9d swank.live-20160208-git swank.live.asd
swap-bytes http://beta.quicklisp.org/archive/swap-bytes/2019-11-30/swap-bytes-v1.2.tgz 4342 eea516d7fdbe20bc963a6708c225d719 e1ab274454408933c57dd932be413f0b11f18444 swap-bytes-v1.2 swap-bytes.asd
sxql http://beta.quicklisp.org/archive/sxql/2021-06-30/sxql-20210630-git.tgz 26680 cf2310671511527a490184f05ea6b7ed 1dd59585fc517b06bbc27501ca8359f8a3ef94a5 sxql-20210630-git sxql-test.asd sxql.asd
sxql-composer http://beta.quicklisp.org/archive/sxql-composer/2020-03-25/sxql-composer-20200325-git.tgz 2967 bfca2d302b62b46a90a4c4effa3f3e54 7af4ac339fb7cd05241221836b47b8b5bc426d54 sxql-composer-20200325-git sxql-composer.asd
sycamore http://beta.quicklisp.org/archive/sycamore/2021-10-20/sycamore-20211020-git.tgz 56384 0a9f35519b5cb3e5f9467427632ff0f8 8d7d5a43dcab099f04d8b112a095452549676461 sycamore-20211020-git src/sycamore.asd
symbol-munger http://beta.quicklisp.org/archive/symbol-munger/2022-02-20/symbol-munger-20220220-git.tgz 5164 1490f027785e2ca1ec7cd138cd2864ce 92188ad0c2fcbc75857c0edf86d1d4b2349e8ec3 symbol-munger-20220220-git symbol-munger.asd
symbol-namespaces http://beta.quicklisp.org/archive/symbol-namespaces/2013-01-28/symbol-namespaces-1.0.tgz 4915 0ffbf4f50332e324feb40269ca1848cd 1088d4f5d922d472fc16a77da01c498ec956a9a7 symbol-namespaces-1.0 symbol-namespaces.asd
synonyms http://beta.quicklisp.org/archive/synonyms/2019-03-07/synonyms-20190307-hg.tgz 1628 6f956534aa5f68cd03988303fdc40f30 2a5f07c4a581566a998f4a56048850c9e7f6268b synonyms-20190307-hg synonyms.asd
system-locale http://beta.quicklisp.org/archive/system-locale/2020-06-10/system-locale-20200610-git.tgz 6250 01cb055dffb694ede75c0bdf8dc792d0 42dce53529ee6fb95f9ec7705366d54f923ec3bf system-locale-20200610-git system-locale.asd
tagger http://beta.quicklisp.org/archive/tagger/2020-07-15/tagger-20200715-git.tgz 1108833 ee0d4eee120eb0895f000257b64687b1 db86d5219d8fe0fceb70c713bbc4b6c30508da06 tagger-20200715-git tagger.asd
taglib http://beta.quicklisp.org/archive/taglib/2021-04-11/taglib-20210411-git.tgz 49547 836af420af19428b002b4a157eafc2c7 365b92fb89ed57e68ad073f5d6c46db1e88211cc taglib-20210411-git taglib-tests.asd taglib.asd
tailrec http://beta.quicklisp.org/archive/tailrec/2021-08-07/tailrec-20210807-git.tgz 12360 9e8f4805ed0641797c0916ee824e450f e18b3cdfde372bdb42b3d332b0f45f58bd8ecb36 tailrec-20210807-git tailrec.asd
talcl http://beta.quicklisp.org/archive/talcl/2018-02-28/talcl-20180228-git.tgz 32272 12f54d47f90bc8385b3fa8bc4ded7530 39bf555e8bcdb9497663597dc6fe0d725d4c9388 talcl-20180228-git talcl.asd
tap-unit-test http://beta.quicklisp.org/archive/tap-unit-test/2017-12-27/tap-unit-test-20171227-git.tgz 6640 999414b562bcad22ad8be263d13cf813 bee7f65ad728387c7496f6ee412711c2982d8d7c tap-unit-test-20171227-git tap-unit-test.asd
targa http://beta.quicklisp.org/archive/targa/2018-10-18/targa-20181018-git.tgz 6717 abdb921075c2f42c314bcaa6af93402a 5d82e49c058ae56f9c586a82424f853476023ee7 targa-20181018-git targa.asd
tclcs-code http://beta.quicklisp.org/archive/tclcs-code/2021-01-24/tclcs-code-20210124-git.tgz 22539 ba9b75b597dad7a1f81a314fbd40888a 229b74c9efaef8d69b6631e70cd245b56019ef70 tclcs-code-20210124-git tclcs-code.asd
teddy http://beta.quicklisp.org/archive/teddy/2021-10-20/teddy-20211020-git.tgz 548350 88828f5f6ef802614a0bd88c8acd4613 7b65a916e35d68361a2dd83e4fe9f53a749aeac3 teddy-20211020-git teddy.asd
teepeedee2 http://beta.quicklisp.org/archive/teepeedee2/2020-02-18/teepeedee2-20200218-git.tgz 92850 47604f7e81af325408cf097bafd18964 76dbab7d720d4a4e870a57d024ae879176e32ec9 teepeedee2-20200218-git teepeedee2-test.asd teepeedee2.asd
telnetlib http://beta.quicklisp.org/archive/telnetlib/2014-12-17/telnetlib-20141217-git.tgz 9030 d002d6c2aa8cda700fa7b0e114404197 65dff3a01133aacc554aea10ecfb2d4a95ad6c12 telnetlib-20141217-git telnetlib.asd
template http://beta.quicklisp.org/archive/template/2019-03-07/template-20190307-hg.tgz 3558 f1f963f928879fb2ef6903e5e0466d6d a2a448c28c9b96927ef288929c04f931a86ed63c template-20190307-hg template.asd
template-function http://beta.quicklisp.org/archive/template-function/2017-11-30/template-function-v0.0.1-git.tgz 28074 cfe8ff39d2006b55a46b7f0bdf770ecb 327ad56f17a4923c9124834168791462d5274252 template-function-v0.0.1-git template-function-tests.asd template-function.asd
temporal-functions http://beta.quicklisp.org/archive/temporal-functions/2017-10-19/temporal-functions-20171019-git.tgz 6586 0a4ad318c90a9cc2c7ca391d2c471c1a 70bfe85677d18c3de5434d054d6dd7b6ae3395d4 temporal-functions-20171019-git temporal-functions.asd
temporary-file http://beta.quicklisp.org/archive/temporary-file/2015-06-08/temporary-file-20150608-git.tgz 10812 0df609812523566a84604d768158f3b0 1ac3046923b6136defee3d28344f9c4e69d8e83a temporary-file-20150608-git temporary-file.asd
ten http://beta.quicklisp.org/archive/ten/2022-02-20/ten-20220220-git.tgz 12951 c97fba6bb07904a57fefa30533130856 cb518c87b121e15c7aca8db1074de43d2fd72f59 ten-20220220-git ten.asd ten.examples.asd ten.i18n.cl-locale.asd ten.i18n.gettext.asd ten.tests.asd
terminfo http://beta.quicklisp.org/archive/terminfo/2021-01-24/terminfo-20210124-git.tgz 12758 b4c386aa1c25252ec725647de21d620a ee09cd9f2f3d7303a3cc7b2588eba933dbbcd5f6 terminfo-20210124-git terminfo.asd
terrable http://beta.quicklisp.org/archive/terrable/2019-07-10/terrable-20190710-git.tgz 8756 99d92ae77464827a2c3f17cbcef09388 5b7f6b7821374d913cc4f8aa34968db75a065480 terrable-20190710-git terrable.asd
tesseract-capi http://beta.quicklisp.org/archive/tesseract-capi/2020-12-20/tesseract-capi-20201220-git.tgz 16920 cc5206faf91891373dfaf0e5a0215a27 e8d4b0e6439288963a121e3edccefc90c4d8ffae tesseract-capi-20201220-git tesseract-capi.asd
test-utils http://beta.quicklisp.org/archive/test-utils/2020-06-10/test-utils-20200610-git.tgz 5084 7c8ce4b1311ce35db20f49b106dfad24 d6cac41f82ed3f11ab4ed400c087f610ebdfe005 test-utils-20200610-git test-utils.asd
testbild http://beta.quicklisp.org/archive/testbild/2010-12-07/testbild-20101207-git.tgz 52330 d3008e32481ed01aaf4bf8d2fd0bcbad 95fca0344bb5af81f7f9c0453ed51e24fd27419f testbild-20101207-git testbild-test.asd testbild.asd
testiere http://beta.quicklisp.org/archive/testiere/2022-11-06/testiere-20221106-git.tgz 16440 fc2f73b180ea273ee11cac37edf41dea 9d35c21254232cefe8169997011afd396efe29d6 testiere-20221106-git testiere.asd
texp http://beta.quicklisp.org/archive/texp/2015-12-18/texp-20151218-git.tgz 16321 0ded17b1ba2ad4506e5f4bde9ba9a2d7 e73f7a2267913b386f31b78b6e68ddd4c896de92 texp-20151218-git texp.asd
text-query http://beta.quicklisp.org/archive/text-query/2011-11-05/text-query-1.1.tgz 5548 57d28b552f346a00ece98824b1bc898f f5ec2327f9d7049749d6bea161ea7d90a5db5017 text-query-1.1 text-query.asd
textery http://beta.quicklisp.org/archive/textery/2020-12-20/textery-20201220-git.tgz 4117 41a870dc7b12e26b63317620ac673d4f 7bd30e1bb0456168df12882eb595b70ea6e3c504 textery-20201220-git textery.asd
tfeb-lisp-hax http://beta.quicklisp.org/archive/tfeb-lisp-hax/2022-11-06/tfeb-lisp-hax-20221106-git.tgz 74750 4185668980caa68498954ead261da7ee 94c875660a887423f0432545d73caa048ed491f3 tfeb-lisp-hax-20221106-git org.tfeb.hax.abstract-classes.asd org.tfeb.hax.asd org.tfeb.hax.binding.asd org.tfeb.hax.collecting.asd org.tfeb.hax.comment-form.asd org.tfeb.hax.cs-forms.asd org.tfeb.hax.define-functions.asd org.tfeb.hax.dynamic-state.asd org.tfeb.hax.iterate.asd org.tfeb.hax.memoize.asd org.tfeb.hax.metatronic.asd org.tfeb.hax.object-accessors.asd org.tfeb.hax.read-package.asd org.tfeb.hax.simple-loops.asd org.tfeb.hax.singleton-classes.asd org.tfeb.hax.slog.asd org.tfeb.hax.spam.asd org.tfeb.hax.stringtable.asd org.tfeb.hax.trace-macroexpand.asd org.tfeb.hax.utilities.asd org.tfeb.hax.wrapping-standard.asd
tfeb-lisp-tools http://beta.quicklisp.org/archive/tfeb-lisp-tools/2022-11-06/tfeb-lisp-tools-20221106-git.tgz 34067 37dcc3dc6ba4c72d7e0554d9f6306e92 cd836ce667992eccd446ac5828cf6af400b2c913 tfeb-lisp-tools-20221106-git org.tfeb.tools.asd org.tfeb.tools.asdf-module-sysdcls.asd org.tfeb.tools.build-modules.asd org.tfeb.tools.deprecations.asd org.tfeb.tools.feature-expressions.asd org.tfeb.tools.install-providers.asd org.tfeb.tools.require-module.asd
tfm http://beta.quicklisp.org/archive/tfm/2021-04-11/tfm-20210411-git.tgz 85389 00c8221716755b00f127f568c1e803a0 cb2f38b2d3d1cd6fd7578357a96363aafc9d8c5b tfm-20210411-git core/net.didierverna.tfm.core.asd net.didierverna.tfm.asd setup/net.didierverna.tfm.setup.asd
the-cost-of-nothing http://beta.quicklisp.org/archive/the-cost-of-nothing/2019-11-30/the-cost-of-nothing-20191130-git.tgz 6864 e7b9891f6a3827425124ed8c00b13bab c8f6ee5ed5ee075729d28dcbe354386ba555aab1 the-cost-of-nothing-20191130-git the-cost-of-nothing.asd
thnappy http://beta.quicklisp.org/archive/thnappy/2018-08-31/thnappy-20180831-git.tgz 2879 e399d3a0aea4a4d46b4f3779b083b759 e68599d93d642eb88c3c4ead9a7724c43c34bf5c thnappy-20180831-git thnappy.asd
thorn http://beta.quicklisp.org/archive/thorn/2015-06-08/thorn-20150608-git.tgz 4539 efcc67773fb54b4e4680d50ed5091f9a 436eb3485d54524cc23cc97d1d30ea4f3d1af29b thorn-20150608-git thorn-doc.asd thorn-test.asd thorn.asd
thread-pool http://beta.quicklisp.org/archive/thread-pool/2012-01-07/thread-pool-20120107-git.tgz 3061 9dfcb3dd5692d474d90f7916722d5bf8 5754230b3648ae4d84f80a8cf552518d6851e96b thread-pool-20120107-git thread-pool.asd
thread.comm.rendezvous http://beta.quicklisp.org/archive/thread.comm.rendezvous/2012-10-13/thread.comm.rendezvous-20121013-git.tgz 3295 819e6c2c9fc715f47b9fc1fae4dd9620 fb0ada0703f62f9d2c38cd8d100571b087d6f61f thread.comm.rendezvous-20121013-git thread.comm.rendezvous.asd thread.comm.rendezvous.test.asd
tile-grid http://beta.quicklisp.org/archive/tile-grid/2022-07-07/tile-grid-20220707-git.tgz 2460 6746af6b419cd03a1f8ff4d7f41ae381 0b7c1acf141e5f8bfec3455398d873e41c2fe017 tile-grid-20220707-git tile-grid.asd
time-interval http://beta.quicklisp.org/archive/time-interval/2019-02-02/time-interval-20190202-git.tgz 3914 be8f598fa583bc02d5aef61c9da05497 2e3b1a01d3aca24e573fdf98ce81b5a15909ce2c time-interval-20190202-git time-interval.asd
timer-wheel http://beta.quicklisp.org/archive/timer-wheel/2018-02-28/timer-wheel-20180228-git.tgz 6804 aecee06490b30b7395bd6bf8e30e293f f5394005e0e5214210a8dd1a0d41fd35674c364d timer-wheel-20180228-git timer-wheel.asd timer-wheel.examples.asd
tinaa http://beta.quicklisp.org/archive/tinaa/2017-12-27/tinaa-20171227-git.tgz 80171 bc067fbe6af7f03f247e93c0d35c5f3a 7cb5eed990ef9deaa609f923c9361840131a90f2 tinaa-20171227-git tinaa-test.asd tinaa.asd
tiny-routes http://beta.quicklisp.org/archive/tiny-routes/2022-03-31/tiny-routes-20220331-git.tgz 10829 e09dccb34615059cb3e3be37858de920 0b411b225d785ec332d2eca5bbefcb1f7b187a30 tiny-routes-20220331-git tiny-routes.asd
tm http://beta.quicklisp.org/archive/tm/2018-02-28/tm-v0.8.tgz 173992 8c2219879aa24677951a02235855dcf6 dbe34f193e9e3e16b829d8516ef3c510322408c0 tm-v0.8 tm.asd
tmpdir http://beta.quicklisp.org/archive/tmpdir/2020-02-18/tmpdir-20200218-git.tgz 2080 9d1147084d923c1470e9eb003b97f468 ad4713528770d3b00ca247a0e69dc3195cc32424 tmpdir-20200218-git tmpdir.asd tmpdir.tests.asd
toadstool http://beta.quicklisp.org/archive/toadstool/2013-06-15/toadstool-20130615-git.tgz 14309 8bd093fb81edf56821b538339c70c1f1 404dd62b14525f642110dfd30dadbe4e753f1e9f toadstool-20130615-git toadstool-tests.asd toadstool.asd
toot http://beta.quicklisp.org/archive/toot/2012-11-25/toot-20121125-git.tgz 57834 569c801b0b9e880977df5ab9743ec23c b97041f2040590e8751eae383532996923ec5ad0 toot-20121125-git toot.asd
tooter http://beta.quicklisp.org/archive/tooter/2022-02-20/tooter-20220220-git.tgz 46028 94dbd906f76913dfcd9ccb9bb887e13b 962efb190469d4e47bad8daa001391bc24e9e04e tooter-20220220-git tooter.asd
towers http://beta.quicklisp.org/archive/towers/2014-12-17/towers-20141217-git.tgz 17597 2af927bf9a75351e0216b45dafef01ce 8949f07d1929307532b2b9ad4009480ea166c808 towers-20141217-git towers.asd
trace-db http://beta.quicklisp.org/archive/trace-db/2022-11-06/trace-db-20221106-git.tgz 207229 9f1e2fdceecec7ee8043621184811c78 554f34302a9189142bedadef47ecb4c68a7e5b2c trace-db-20221106-git trace-db.asd
track-best http://beta.quicklisp.org/archive/track-best/2022-02-20/track-best-20220220-git.tgz 6167 8e5d910c4f6a72b57256dad257648b81 69d1047057e89ca2418b87e8a6e2149c799bba03 track-best-20220220-git track-best.asd
trainable-object http://beta.quicklisp.org/archive/trainable-object/2019-12-27/trainable-object-20191227-git.tgz 19230 9db5fb29c21927d7d1aee421e673ee66 bcb41c52a7278aaf9c381b14218eb79617290766 trainable-object-20191227-git trainable-object.asd trainable-object.test.asd
translate http://beta.quicklisp.org/archive/translate/2018-02-28/translate-20180228-git.tgz 6688 95c46dec58c83cd01efd27d60049712f 8660e413ff82b5e83b42bb0d3a64990ee1383db7 translate-20180228-git translate.asd
translate-client http://beta.quicklisp.org/archive/translate-client/2018-02-28/translate-client-20180228-git.tgz 4495 94b7fb3e9836500104348162732512be bdf15a4a38460632c85d3979ef08ea27e79f8c3c translate-client-20180228-git translate-client.asd
transparent-wrap http://beta.quicklisp.org/archive/transparent-wrap/2020-09-25/transparent-wrap-20200925-git.tgz 9955 a82773c9dec366fdf2da8f52a716a7fd 60be87e9f50ecbbde5038341a990ab8e5aaa18f4 transparent-wrap-20200925-git transparent-wrap.asd
tree-search http://beta.quicklisp.org/archive/tree-search/2020-12-20/tree-search-0.0.1.tgz 2039 34f3fc86a9d123841045ead78556bd77 e763a3149fbbe9b4798af346690b8821e1736666 tree-search-0.0.1 tree-search.asd
treedb http://beta.quicklisp.org/archive/treedb/2016-08-25/treedb-20160825-git.tgz 16294 af216acd41ca7a14497d3f045af39b26 d12e833c2d1c271e6ef49bc189a51ccd8f4edfde treedb-20160825-git doc/treedb.doc.asd tests/treedb.tests.asd treedb.asd
trees http://beta.quicklisp.org/archive/trees/2018-01-31/trees-20180131-git.tgz 20019 a1b156d15d444d114f475f7abc908064 3e5523710bbc6c5d96894e036377fbb4487460f9 trees-20180131-git trees.asd
trestrul http://beta.quicklisp.org/archive/trestrul/2021-10-20/trestrul-20211020-git.tgz 8313 9d768924c4b9b74e536c0c6a705029a9 0e78a8985e9578cd6957f1f5a672a93bb39f9100 trestrul-20211020-git spec/trestrul.test.asd trestrul.asd
trivia http://beta.quicklisp.org/archive/trivia/2022-07-07/trivia-20220707-git.tgz 62027 9aabbb90a45b24c6e2e98ca0c4aed4a8 36c5f42a0a1bc6b0d0254addc16de0ac754df0e9 trivia-20220707-git trivia.asd trivia.balland2006.asd trivia.benchmark.asd trivia.cffi.asd trivia.fset.asd trivia.level0.asd trivia.level1.asd trivia.level2.asd trivia.ppcre.asd trivia.quasiquote.asd trivia.test.asd trivia.trivial.asd
trivial-arguments http://beta.quicklisp.org/archive/trivial-arguments/2020-09-25/trivial-arguments-20200925-git.tgz 3397 3d7b76a729b272019c8827e40bfb6db8 20ed920b2c283ae5c02844d43eae4b9a4eab84fa trivial-arguments-20200925-git trivial-arguments.asd
trivial-backtrace http://beta.quicklisp.org/archive/trivial-backtrace/2020-06-10/trivial-backtrace-20200610-git.tgz 9230 1d9a7cc7c5840e4eba84c89648908525 69be935e72ea6ead812ff2579208e511fd233a45 trivial-backtrace-20200610-git trivial-backtrace-test.asd trivial-backtrace.asd
trivial-battery http://beta.quicklisp.org/archive/trivial-battery/2021-10-20/trivial-battery-20211020-git.tgz 2172 9418bbc845f5a361b947f3689031b2a3 f13fceb155f8e99202ae1d9c99ff0e140b4e4803 trivial-battery-20211020-git trivial-battery.asd
trivial-benchmark http://beta.quicklisp.org/archive/trivial-benchmark/2022-07-07/trivial-benchmark-20220707-git.tgz 15036 ffe529f1006c31a49dcc65ac1bdf8cc3 e9739681f3f2b9b63ecffe348285956c8aafc439 trivial-benchmark-20220707-git trivial-benchmark.asd
trivial-bit-streams http://beta.quicklisp.org/archive/trivial-bit-streams/2019-07-10/trivial-bit-streams-20190710-git.tgz 7667 c08ad7b58a972f45c4939ad6869a9283 819805e50d470ec6b09ee0ea53889f633754408e trivial-bit-streams-20190710-git trivial-bit-streams-tests.asd trivial-bit-streams.asd
trivial-build http://beta.quicklisp.org/archive/trivial-build/2015-12-18/trivial-build-20151218-git.tgz 3150 51479b61f4cbe7a113065b0f3ac50834 654770325c8c5ebd1632430aae2bc3f4ac027fd7 trivial-build-20151218-git trivial-build-test.asd trivial-build.asd
trivial-channels http://beta.quicklisp.org/archive/trivial-channels/2016-04-21/trivial-channels-20160421-git.tgz 2810 7bd8731f8ffbbc61aeaf7fde3309c2a3 2c856642b1ac4006d2f8a1f8bd55d18697c9329e trivial-channels-20160421-git trivial-channels.asd
trivial-clipboard http://beta.quicklisp.org/archive/trivial-clipboard/2022-11-06/trivial-clipboard-20221106-git.tgz 4650 5a0ae4b05bd20330b1b23901b8a3a90b 415bc7a3a340f427e409b6a24a7da4224a167cf4 trivial-clipboard-20221106-git trivial-clipboard-test.asd trivial-clipboard.asd
trivial-cltl2 http://beta.quicklisp.org/archive/trivial-cltl2/2021-12-30/trivial-cltl2-20211230-git.tgz 6394 1724626b5c6081d9d8860640166c69a7 e85dab8698a8e6aa2fa4692b5bcc5d67274bb684 trivial-cltl2-20211230-git trivial-cltl2.asd
trivial-coerce http://beta.quicklisp.org/archive/trivial-coerce/2022-07-07/trivial-coerce-20220707-git.tgz 5821 cbd34851987e93c43b38d2960b8aedea 76698cff35e85c0889861c081ff9cbe548af4847 trivial-coerce-20220707-git trivial-coerce.asd
trivial-compress http://beta.quicklisp.org/archive/trivial-compress/2020-12-20/trivial-compress-20201220-git.tgz 2800 e42dd11e969cfc1bd09af9c2352ba874 6ee23d6b31c1841cd8ab9a64afdcd617f2b0e947 trivial-compress-20201220-git trivial-compress-test.asd trivial-compress.asd
trivial-continuation http://beta.quicklisp.org/archive/trivial-continuation/2019-10-07/trivial-continuation-20191007-git.tgz 6021 cd66f3f621bd6004b18c8cfb834fa61c b031d2c2d477949c038e14b9a84fb13cba7f5ae6 trivial-continuation-20191007-git trivial-continuation.asd
trivial-coverage http://beta.quicklisp.org/archive/trivial-coverage/2020-02-18/trivial-coverage-20200218-git.tgz 4414 c5f1c656f46de68d5da349b56ec1b82c a7f10c7eed17b92a30b8413a3d8b25d7c6e44b1f trivial-coverage-20200218-git trivial-coverage.asd
trivial-custom-debugger http://beta.quicklisp.org/archive/trivial-custom-debugger/2020-09-25/trivial-custom-debugger-20200925-git.tgz 3544 e827a5d5c9586c2dc6db8d6b3d0dd40f 9b5591da1181fe253ea7b8b6eb50d71dc5a63a2a trivial-custom-debugger-20200925-git trivial-custom-debugger.asd
trivial-debug-console http://beta.quicklisp.org/archive/trivial-debug-console/2015-04-07/trivial-debug-console-20150407-git.tgz 2602 570ce84cfc527c3ce9a66eb9a3e32a33 c78bc7dbf398faba7518f9edc3fa7ef64ac74768 trivial-debug-console-20150407-git trivial-debug-console.asd
trivial-do http://beta.quicklisp.org/archive/trivial-do/2022-03-31/trivial-do-20220331-git.tgz 2650 911889cba99951fd7b7978f9b42cee3e a4816471ad9b5aa4f063d74a5f638ea9770fcedc trivial-do-20220331-git trivial-do.asd
trivial-documentation http://beta.quicklisp.org/archive/trivial-documentation/2016-12-04/trivial-documentation-20161204-git.tgz 15596 9f092a90567e4f77dc9bd1d06fa58ed0 be1d89ac255c31e9de3ad7966312cfa1e6cda9e2 trivial-documentation-20161204-git trivial-documentation-test.asd trivial-documentation.asd
trivial-download http://beta.quicklisp.org/archive/trivial-download/2020-09-25/trivial-download-20200925-git.tgz 3776 24928b34e56068a7cf939d5c56463fff c975d97de65d514f66b82ce1f52f4a8dcc8ec68e trivial-download-20200925-git trivial-download.asd
trivial-dump-core http://beta.quicklisp.org/archive/trivial-dump-core/2017-02-27/trivial-dump-core-20170227-git.tgz 5550 1ba1e853c238b2545002db6ee9530144 8a54cef6a4d0dea05cb5844ebb44f0cf03da762d trivial-dump-core-20170227-git trivial-dump-core.asd
trivial-ed-functions http://beta.quicklisp.org/archive/trivial-ed-functions/2021-08-07/trivial-ed-functions-20210807-git.tgz 2789 0efb515d097f5f8efb559f9cf8f507e7 59d59fce7eb04ec732b501f5cc72788df4670269 trivial-ed-functions-20210807-git trivial-ed-functions.asd
trivial-escapes http://beta.quicklisp.org/archive/trivial-escapes/2018-02-28/trivial-escapes-20180228-git.tgz 6079 b8afeb445f9a3fd8e046d5899fd21e2e 102cfd6ba8f9af527302062704cbd04974848bae trivial-escapes-20180228-git test/trivial-escapes-test.asd trivial-escapes.asd
trivial-exe http://beta.quicklisp.org/archive/trivial-exe/2015-12-18/trivial-exe-20151218-git.tgz 1983 d85a8e198c31aa3d6c07351a41732e49 a860186969c29240babffd1c0e2209635a5e2e3a trivial-exe-20151218-git trivial-exe-test.asd trivial-exe.asd
trivial-extensible-sequences http://beta.quicklisp.org/archive/trivial-extensible-sequences/2022-11-06/trivial-extensible-sequences-20221106-git.tgz 15515 146d7365fbc40fc996980fc7c6486d17 4b3c0bc0317c8f317e3104ffd4d7f9a559d91fc7 trivial-extensible-sequences-20221106-git trivial-extensible-sequences.asd
trivial-extract http://beta.quicklisp.org/archive/trivial-extract/2016-04-21/trivial-extract-20160421-git.tgz 3545 b9c3ede33a7f4d565f6916a52a6ea708 c89c03f8cd08876c412a3ae40b0ac763b1930635 trivial-extract-20160421-git trivial-extract-test.asd trivial-extract.asd
trivial-features http://beta.quicklisp.org/archive/trivial-features/2021-12-09/trivial-features-20211209-git.tgz 11377 eca3e353c7d7f100a07a5aeb4de02098 b0fdd2120b75486b8cf0320d27b2cbcdb4f694db trivial-features-20211209-git trivial-features-tests.asd trivial-features.asd
trivial-file-size http://beta.quicklisp.org/archive/trivial-file-size/2022-11-06/trivial-file-size-20221106-git.tgz 3225 8293365da6dc57f4831f5e0a56f8bb56 beb8230dbe372ea3bc860b3ad3e07b13c6c5d0d6 trivial-file-size-20221106-git trivial-file-size.asd
trivial-garbage http://beta.quicklisp.org/archive/trivial-garbage/2021-12-30/trivial-garbage-20211230-git.tgz 10996 6e2b3c0360733f30c7ed36357eb8d54a e246e1350d57823f1aca63747ddc2414f934483b trivial-garbage-20211230-git trivial-garbage.asd
trivial-gray-streams http://beta.quicklisp.org/archive/trivial-gray-streams/2021-01-24/trivial-gray-streams-20210124-git.tgz 8046 1b93af1cae9f8465d813964db4d10588 1a899121477a783ea3996c9875f44db44e8cd089 trivial-gray-streams-20210124-git trivial-gray-streams-test.asd trivial-gray-streams.asd
trivial-hashtable-serialize http://beta.quicklisp.org/archive/trivial-hashtable-serialize/2019-10-07/trivial-hashtable-serialize-20191007-git.tgz 4010 9983c4dff65eb69b0eadb067cf03a834 79afe82d413cd42fbcd64a6f66a7bdb0f15ad245 trivial-hashtable-serialize-20191007-git trivial-hashtable-serialize.asd
trivial-http http://beta.quicklisp.org/archive/trivial-http/2011-02-19/trivial-http-20110219-http.tgz 12646 9f6b15eb07fd99fd0b6b69387a520a4f c71ab658c7c6a98eefdd9a69f8d358a9752bb1dc trivial-http-20110219-http trivial-http-test.asd trivial-http.asd
trivial-indent http://beta.quicklisp.org/archive/trivial-indent/2021-05-31/trivial-indent-20210531-git.tgz 3564 3bb7d208d9d0614121c1f57fcffe65c7 b5282042ed3f4b8dfdefba8665f0f56bdce6baaa trivial-indent-20210531-git trivial-indent.asd
trivial-inspector-hook http://beta.quicklisp.org/archive/trivial-inspector-hook/2021-08-07/trivial-inspector-hook-20210807-git.tgz 2574 9f29b2cf709949e784cc978a44d276f5 f8ecefed709afd0acf43f4017b2273535674fe3a trivial-inspector-hook-20210807-git trivial-inspector-hook.asd
trivial-irc http://beta.quicklisp.org/archive/trivial-irc/2017-10-19/trivial-irc-20171019-git.tgz 22705 e63a9436c7db593d5aab25d4eb89679b 1fd2165891ad015f7d978e275dc7f99063a605fa trivial-irc-20171019-git trivial-irc-echobot.asd trivial-irc.asd
trivial-json-codec http://beta.quicklisp.org/archive/trivial-json-codec/2022-07-07/trivial-json-codec-20220707-git.tgz 8091 b6364d56a543bc6a71958ddc8cb69ea4 cdd79437c47a0dc94f24bb5ab2e3ee16f9073fb0 trivial-json-codec-20220707-git trivial-json-codec.asd
trivial-jumptables http://beta.quicklisp.org/archive/trivial-jumptables/2019-11-30/trivial-jumptables_1.1.tgz 12374 f8ef2c3b2659c6874a0d3f5555b353af 83d069ac067e1a258ad39ee3b5d0cc437f33469f trivial-jumptables_1.1 tests/trivial-jumptables_tests.asd trivial-jumptables.asd
trivial-lazy http://beta.quicklisp.org/archive/trivial-lazy/2015-07-09/trivial-lazy-20150709-git.tgz 1714 ebb499de9ea8b79b0d580222d36ddee9 e9b99256aeec0f0184f3ae5cf20a9e294c1dd972 trivial-lazy-20150709-git trivial-lazy.asd
trivial-ldap http://beta.quicklisp.org/archive/trivial-ldap/2018-07-11/trivial-ldap-20180711-git.tgz 28258 355759d2c532a377b0ec3c0a689548fd 160ff42b50f8f664b029cb53e598301cd8f2d7f4 trivial-ldap-20180711-git trivial-ldap.asd
trivial-left-pad http://beta.quicklisp.org/archive/trivial-left-pad/2019-08-13/trivial-left-pad-20190813-git.tgz 6592 04a7ef287111319605989f582bf7ce4f 544fa2a3c678fe11f7a5a65e7f3e591abf9bcd5e trivial-left-pad-20190813-git trivial-left-pad.asd
trivial-macroexpand-all http://beta.quicklisp.org/archive/trivial-macroexpand-all/2017-10-23/trivial-macroexpand-all-20171023-git.tgz 1968 9cec494869344eb64ebce802c01928c5 87006c97029637389a4371efc28ba43ececfc315 trivial-macroexpand-all-20171023-git trivial-macroexpand-all.asd
trivial-main-thread http://beta.quicklisp.org/archive/trivial-main-thread/2019-07-10/trivial-main-thread-20190710-git.tgz 6114 ab95906f1831aa5b40f271eebdfe11a3 899bc9fa1f863baeece94f9aea0d7f6b7385dbbb trivial-main-thread-20190710-git trivial-main-thread.asd
trivial-method-combinations http://beta.quicklisp.org/archive/trivial-method-combinations/2019-11-30/trivial-method-combinations-20191130-git.tgz 1502 810ed9f3459831000b175970a35c0a0f 323703b64bd61e9dbe911d601c8360e4500c0057 trivial-method-combinations-20191130-git trivial-method-combinations.asd
trivial-mimes http://beta.quicklisp.org/archive/trivial-mimes/2022-11-06/trivial-mimes-20221106-git.tgz 22494 e728464c1ecd990c8d82689cf6185cfe 1ee37c75959da7d3b958e7856f24da7b84b6614f trivial-mimes-20221106-git trivial-mimes.asd
trivial-mmap http://beta.quicklisp.org/archive/trivial-mmap/2021-01-24/trivial-mmap-20210124-git.tgz 3831 6c02cc87b2b0b654e8b42f9bd40594e9 ea5cfb87e7bc946895c3bbcb455b78ead070090d trivial-mmap-20210124-git trivial-mmap.asd
trivial-monitored-thread http://beta.quicklisp.org/archive/trivial-monitored-thread/2022-07-07/trivial-monitored-thread-20220707-git.tgz 6578 7cc0b646eb4733603bd993d4069e9ebd b17a267a982940709dd2b793e54b1ddf0109f3d5 trivial-monitored-thread-20220707-git trivial-monitored-thread.asd
trivial-msi http://beta.quicklisp.org/archive/trivial-msi/2016-02-08/trivial-msi-20160208-git.tgz 2142 c2b860a6959e61707142419756f7cf3e 0d6d8cf48d175a6616a245801fa44a165baee4c4 trivial-msi-20160208-git trivial-msi-test.asd trivial-msi.asd
trivial-nntp http://beta.quicklisp.org/archive/trivial-nntp/2016-12-04/trivial-nntp-20161204-git.tgz 4937 f03c13ee62ce27792941d9f9d8cd7c43 b311c46a549c4dbffaed13b8c338ce976ad7b892 trivial-nntp-20161204-git trivial-nntp.asd
trivial-object-lock http://beta.quicklisp.org/archive/trivial-object-lock/2022-07-07/trivial-object-lock-20220707-git.tgz 128519 028a5e195db6962351d74b4a121e8042 8070dda223df1ef711dfab7cc99f31a09d78d5d9 trivial-object-lock-20220707-git trivial-object-lock.asd
trivial-octet-streams http://beta.quicklisp.org/archive/trivial-octet-streams/2013-01-28/trivial-octet-streams-20130128-git.tgz 3452 00d2c8cd41b5ace65519f366bc6542fb e0b865e9b1787e6f91b5d5e6c454a1a5890e077e trivial-octet-streams-20130128-git trivial-octet-streams.asd
trivial-open-browser http://beta.quicklisp.org/archive/trivial-open-browser/2016-08-25/trivial-open-browser-20160825-git.tgz 1176 038c4cd110fa9b34a77fe655bc1e35ba bac02728c1ed3037f88b89764dacf204bb8a1b4a trivial-open-browser-20160825-git trivial-open-browser.asd
trivial-openstack http://beta.quicklisp.org/archive/trivial-openstack/2016-06-28/trivial-openstack-20160628-git.tgz 9849 fd4cea1d1a6e3079f4778c226fbb08b1 d7bb60c337b47ad21205099b8ac38efb7b48bd59 trivial-openstack-20160628-git trivial-openstack-test.asd trivial-openstack.asd
trivial-package-local-nicknames http://beta.quicklisp.org/archive/trivial-package-local-nicknames/2022-02-20/trivial-package-local-nicknames-20220220-git.tgz 3827 d6959b6dd52f354bafa5fa6bcb7b42a1 b1d0d4d699b4bafda4c2235160a3b77c3b4df290 trivial-package-local-nicknames-20220220-git trivial-package-local-nicknames.asd
trivial-package-locks http://beta.quicklisp.org/archive/trivial-package-locks/2021-12-30/trivial-package-locks-20211230-git.tgz 3675 5a38e6a370966aab2ebd10991f0a1cbc 2a7eeb031e8efb264111f7c2a8c585ca6d9bc735 trivial-package-locks-20211230-git trivial-package-locks.asd
trivial-package-manager http://beta.quicklisp.org/archive/trivial-package-manager/2017-12-27/trivial-package-manager-20171227-git.tgz 6042 161ae810ca261f04aae86068365839da bdda9666a328e2d6e8278fceb8d6b9dff46e1c31 trivial-package-manager-20171227-git trivial-package-manager.asd trivial-package-manager.test.asd
trivial-pooled-database http://beta.quicklisp.org/archive/trivial-pooled-database/2020-12-20/trivial-pooled-database-20201220-git.tgz 6268 b7f41f2e8a9c273d1221899ed46b7c1d eeed3be17989e423a1dd6f0076453f9045c7c0ae trivial-pooled-database-20201220-git trivial-pooled-database.asd
trivial-project http://beta.quicklisp.org/archive/trivial-project/2017-08-30/trivial-project-quicklisp-9e3fe231-git.tgz 7676 1702cda33bf5d228c4f865f4ca2f28da f9050c412d5c9851d3f384000a6b8b8eaab82473 trivial-project-quicklisp-9e3fe231-git trivial-project.asd
trivial-raw-io http://beta.quicklisp.org/archive/trivial-raw-io/2014-12-17/trivial-raw-io-20141217-git.tgz 2861 627f83a54a94278675c03c14934b272a f89b8c4e06554471bfcb9216dd2eb385b5dd8e8a trivial-raw-io-20141217-git trivial-raw-io.asd
trivial-renamer http://beta.quicklisp.org/archive/trivial-renamer/2017-08-30/trivial-renamer-quicklisp-1282597d-git.tgz 3794 ff77e08decb7ca7b5b18e7b03c6cb05b 071cd2c4f5eb569ca958dbfd91a8effb3f0df647 trivial-renamer-quicklisp-1282597d-git trivial-renamer.asd
trivial-rfc-1123 http://beta.quicklisp.org/archive/trivial-rfc-1123/2022-07-07/trivial-rfc-1123-20220707-git.tgz 5492 678efb57d23c4fbc959bcfe833587151 423d6a908b157610c1771924b26806a8fdb11c60 trivial-rfc-1123-20220707-git trivial-rfc-1123.asd
trivial-sanitize http://beta.quicklisp.org/archive/trivial-sanitize/2022-11-06/trivial-sanitize-20221106-git.tgz 18931 b088903dbf3b12a02adfcb8fdb8e6ed3 b8e9f57ab2a1a3438cd5c142a37bf17e6c4ebf98 trivial-sanitize-20221106-git trivial-sanitize-tests.asd trivial-sanitize.asd
trivial-shell http://beta.quicklisp.org/archive/trivial-shell/2018-02-28/trivial-shell-20180228-git.tgz 14473 d7b93648abd06be95148d43d09fa2ed0 cea06f83f2a0a7f17ba75b612535dc2676296025 trivial-shell-20180228-git trivial-shell-test.asd trivial-shell.asd
trivial-signal http://beta.quicklisp.org/archive/trivial-signal/2019-07-10/trivial-signal-20190710-git.tgz 13446 835a39ed6f968c22862be53487bab640 f1eda45929be115101e995590fefd4fcf8abd6f3 trivial-signal-20190710-git trivial-signal.asd
trivial-sockets http://beta.quicklisp.org/archive/trivial-sockets/2019-01-07/trivial-sockets-20190107-git.tgz 11603 bd56e19a9716b8beb0d482d38fc16472 da768132611e7d7ff0b44212a8011bf17b45e99f trivial-sockets-20190107-git trivial-sockets.asd
trivial-ssh http://beta.quicklisp.org/archive/trivial-ssh/2019-11-30/trivial-ssh-20191130-git.tgz 16118 d1b5dcc547de445a4fde156b66942ab1 001183c4093a3ff5b6133f9f81327f062842d8a5 trivial-ssh-20191130-git trivial-ssh-libssh2.asd trivial-ssh-test.asd trivial-ssh.asd
trivial-string-template http://beta.quicklisp.org/archive/trivial-string-template/2020-12-20/trivial-string-template-20201220-git.tgz 9793 3eeaa59237394b0bdc5f645219e355aa 4bcea2910724eeaabdbcd0200f7e4144c0df3fe2 trivial-string-template-20201220-git trivial-string-template-test.asd trivial-string-template.asd
trivial-tco http://beta.quicklisp.org/archive/trivial-tco/2013-10-03/trivial-tco-20131003-git.tgz 2541 9123b9c05aec84967cb9db6648c958f4 2416c68735324bfec2f53d16abfd76cc29846861 trivial-tco-20131003-git trivial-tco-test.asd trivial-tco.asd
trivial-thumbnail http://beta.quicklisp.org/archive/trivial-thumbnail/2019-07-10/trivial-thumbnail-20190710-git.tgz 5331 c8bfe5f627830e849104d7e0ba54bca6 86865b4054ada83afe01f1a5fbebf35076328215 trivial-thumbnail-20190710-git trivial-thumbnail.asd
trivial-timeout http://beta.quicklisp.org/archive/trivial-timeout/2021-12-09/trivial-timeout-20211209-git.tgz 8989 4a4e8c5d290c860b5d6ae35378413596 5fd697e0d8323725d7a0dd4ad090921bfa8de5da trivial-timeout-20211209-git trivial-timeout.asd
trivial-timer http://beta.quicklisp.org/archive/trivial-timer/2021-05-31/trivial-timer-20210531-git.tgz 6060 16a1f8cadb31f234a77a673ead9acc44 92bafca098d4689410b25e0cbaf9df99977d78b9 trivial-timer-20210531-git trivial-timer.asd
trivial-types http://beta.quicklisp.org/archive/trivial-types/2012-04-07/trivial-types-20120407-git.tgz 3228 b14dbe0564dcea33d8f4e852a612d7db acf9e5a4b0ef99bdcb121cfbc8f07c647c302e57 trivial-types-20120407-git trivial-types.asd
trivial-update http://beta.quicklisp.org/archive/trivial-update/2018-01-31/trivial-update-20180131-git.tgz 2718 d8c0e6814b49272876ea768cd1e46e2f 4b672e0127418b00f5c12a21f24f5db7cc8af279 trivial-update-20180131-git trivial-update.asd
trivial-utf-8 http://beta.quicklisp.org/archive/trivial-utf-8/2022-02-20/trivial-utf-8-20220220-git.tgz 6976 7c9e40bde1c7f5579bbc71e1e3c22eb0 e8ea1dcd00773fb30093a6f4b6df172a5d175b64 trivial-utf-8-20220220-git trivial-utf-8.asd
trivial-utilities http://beta.quicklisp.org/archive/trivial-utilities/2022-07-07/trivial-utilities-20220707-git.tgz 6882 c2a5e8eb0786cc6ade1b7e3b1fe8146e feaeb81695be9f573c07e0ae275ecde358c1b856 trivial-utilities-20220707-git trivial-utilities.asd
trivial-variable-bindings http://beta.quicklisp.org/archive/trivial-variable-bindings/2019-10-07/trivial-variable-bindings-20191007-git.tgz 4594 13e84f4912598f04d5da6a4bd4c7be5f 8bfa3f68d6b82a13767f88f5595cecc8a6df2d3a trivial-variable-bindings-20191007-git trivial-variable-bindings.asd
trivial-wish http://beta.quicklisp.org/archive/trivial-wish/2017-06-30/trivial-wish-quicklisp-910afeea-git.tgz 3604 37c6d054b8047635f893bcca3b20043f 477cbc87778ab161717f3247495b99ce82d26fe0 trivial-wish-quicklisp-910afeea-git trivial-wish.asd
trivial-with http://beta.quicklisp.org/archive/trivial-with/2017-08-30/trivial-with-quicklisp-2fd8ca54-git.tgz 1554 8b816ed9e2c29f3f8015efb749417e1f ee005208b66ede42608dd15837b701d270932620 trivial-with-quicklisp-2fd8ca54-git trivial-with.asd
trivial-with-current-source-form http://beta.quicklisp.org/archive/trivial-with-current-source-form/2021-10-20/trivial-with-current-source-form-20211020-git.tgz 36908 b4a3721cbef6101de1c43c540b446efc 07dba0515a945be80ef2e993b30c1e7bea63859e trivial-with-current-source-form-20211020-git trivial-with-current-source-form.asd
trivial-ws http://beta.quicklisp.org/archive/trivial-ws/2018-01-31/trivial-ws-20180131-git.tgz 2798 d94a58b084bfae82b57533be1ab60d22 6b21f895b2401e4b6ba676597db3398d4d45eeaa trivial-ws-20180131-git trivial-ws-client.asd trivial-ws-test.asd trivial-ws.asd
trivial-yenc http://beta.quicklisp.org/archive/trivial-yenc/2016-12-04/trivial-yenc-20161204-git.tgz 24777 3e30073ec4a3aac9eb79bcedd773afd3 63208129d025e58445a65f7da343aaf5a2661d96 trivial-yenc-20161204-git trivial-yenc.asd
trivialib.bdd http://beta.quicklisp.org/archive/trivialib.bdd/2021-12-09/trivialib.bdd-20211209-git.tgz 5628 a140061a2553aa426849e2c01bedcf0e e674b8a5ed4a88c807b1fed7aa8db353100e9334 trivialib.bdd-20211209-git trivialib.bdd.asd trivialib.bdd.test.asd
trivialib.type-unify http://beta.quicklisp.org/archive/trivialib.type-unify/2020-03-25/trivialib.type-unify-20200325-git.tgz 6636 78d639eb1e7eda0e73a003854457938c 5c418715ea5055ed60e1f9e4315c98dfbe424db0 trivialib.type-unify-20200325-git trivialib.type-unify.asd trivialib.type-unify.test.asd
trucler http://beta.quicklisp.org/archive/trucler/2022-07-07/trucler-20220707-git.tgz 31733 2ab7483930f73d77ef77dc817729a8b7 e1be4062e678dcaec75eb9b3d2fbea7241bb980a trucler-20220707-git Code/Implementations/Native/Test/trucler-native-test.asd Code/Implementations/Native/trucler-native.asd Code/Implementations/Reference/trucler-reference.asd Code/trucler-base.asd Code/trucler.asd
truetype-clx http://beta.quicklisp.org/archive/truetype-clx/2020-02-18/truetype-clx-20200218-git.tgz 4022 78e52139bd604bed152972e39b46db2c e12cb1bd1ed1d70787c57d796d86bb274d8266bb truetype-clx-20200218-git truetype-clx.asd
try http://beta.quicklisp.org/archive/try/2022-03-31/try-20220331-git.tgz 134744 33bf4a38021c6d7c7b8f259872dfb355 877b28c7ec26f0be147223a5d7692c2cdda227d2 try-20220331-git try.asd try.asdf.asd
tsqueue http://beta.quicklisp.org/archive/tsqueue/2022-11-06/tsqueue-20221106-git.tgz 5253 75cbbc8e65c5b6c2e7fe46a0bfd7f2ae fb7673d5ff8d83314bd79de9dd263328e7b0f43b tsqueue-20221106-git tsqueue.asd
ttt http://beta.quicklisp.org/archive/ttt/2022-07-07/ttt-20220707-git.tgz 1339408 726170159da82e2e9963a3ea02173dc9 6751e8408aae525fbf089ba12507beb8fb8eebfd ttt-20220707-git src/ttt.asd
twfy http://beta.quicklisp.org/archive/twfy/2013-04-20/twfy-20130420-git.tgz 6872 970b20e4c143014bf2faf5d470e3cf72 3840c3c70a63c07bf225bea595bc196ed243b17c twfy-20130420-git twfy.asd
type-i http://beta.quicklisp.org/archive/type-i/2022-07-07/type-i-20220707-git.tgz 5990 b4741e4ae0b614598f240078540903f8 424e1d745e2062bfd975ee2833ef69c35bf30b26 type-i-20220707-git type-i.asd type-i.test.asd
type-r http://beta.quicklisp.org/archive/type-r/2019-12-27/type-r-20191227-git.tgz 10627 9dd5400746e6c8352fc4248e5384669a 82c0916f793c2f678770c2c0152dbd26af130259 type-r-20191227-git type-r.asd type-r.test.asd
typo http://beta.quicklisp.org/archive/typo/2022-11-06/typo-20221106-git.tgz 37125 3c8a9ba1f87ab374d5a299256844f33b 772553956cc2144beac74a8575381f8f3a9c3497 typo-20221106-git code/test-suite/typo.test-suite.asd code/typo.asd
uax-14 http://beta.quicklisp.org/archive/uax-14/2020-09-25/uax-14-20200925-git.tgz 130668 d2ed691427a0bb0f84d4bf22227d7a08 5189b0c0c726677222e011d7f551818617592fe3 uax-14-20200925-git uax-14-test.asd uax-14.asd
uax-15 http://beta.quicklisp.org/archive/uax-15/2022-11-06/uax-15-20221106-git.tgz 834366 489df3b2f037997ed2d0870824568ffa 893a3bc8746f1afbb97feaa35e160e757cd4b46f uax-15-20221106-git uax-15.asd
uax-9 http://beta.quicklisp.org/archive/uax-9/2019-10-07/uax-9-20191007-git.tgz 1794867 dc653d87a4ddfb75efec85030a074cbc 7cdb719c1cdc1b1724860826c9436f71db9898c8 uax-9-20191007-git uax-9-test.asd uax-9.asd
ubiquitous http://beta.quicklisp.org/archive/ubiquitous/2019-07-10/ubiquitous-20190710-git.tgz 43252 f1300d3ed47beda6abc92ef0d85a8eee 30b0eb81f56864c4e07a916d94a849c72577cd9e ubiquitous-20190710-git ubiquitous-concurrent.asd ubiquitous.asd
ucons http://beta.quicklisp.org/archive/ucons/2021-02-28/ucons-20210228-git.tgz 5834 d5f2cfa499ee384b35d0a835a5f4386a c39b6d852d25253dc18052616ab8fe9c48f2eafa ucons-20210228-git code/ucons.asd
ucw http://beta.quicklisp.org/archive/ucw/2016-02-08/ucw-20160208-darcs.tgz 164029 b5a4f28e311b70010bd98be79e544c48 d461b81886f15d368a521ba254c282f224638623 ucw-20160208-darcs ucw-core.asd ucw.asd
uffi http://beta.quicklisp.org/archive/uffi/2018-02-28/uffi-20180228-git.tgz 179928 b0dfb2f966912f4797327948aa7e9119 3fa7b46bc21bcbbc59528bf4c2ea9bda84f57088 uffi-20180228-git uffi-tests.asd uffi.asd
ufo http://beta.quicklisp.org/archive/ufo/2021-08-07/ufo-20210807-git.tgz 5048 262532d5b0759c3f5246a8e18c009d9f 737680d4d0e2649ab3002d7eb373ed8dcfa15513 ufo-20210807-git ufo-test.asd ufo.asd
ugly-tiny-infix-macro http://beta.quicklisp.org/archive/ugly-tiny-infix-macro/2016-08-25/ugly-tiny-infix-macro-20160825-git.tgz 8284 ed38d0a89cf772f96244934a78bc1ec4 3d5e3f693c1f45322d1c7f6d117fa96a3d9d4557 ugly-tiny-infix-macro-20160825-git ugly-tiny-infix-macro.asd
uiop http://beta.quicklisp.org/archive/uiop/2022-11-06/uiop-3.3.6.tgz 105036 812e0f5ac2fbe27ff485c9b00a6a3ad2 cc90b3bd08eec3f34cc0ea74752b1ec77acaa6c9 uiop-3.3.6 asdf-driver.asd uiop.asd
umbra http://beta.quicklisp.org/archive/umbra/2022-07-07/umbra-20220707-git.tgz 24962 a57ed1eb17088e7e350138f68a8e11e3 984dd71b8b937b4f8598389143ef8a1201e7bc12 umbra-20220707-git umbra.asd
umlisp http://beta.quicklisp.org/archive/umlisp/2021-04-11/umlisp-20210411-git.tgz 46998 3cd1f69fa3046bb4d0d2b73b3be9eb46 9ac78a455125749ea9e12e714ba4b600b8c0c202 umlisp-20210411-git umlisp-tests.asd umlisp.asd
umlisp-orf http://beta.quicklisp.org/archive/umlisp-orf/2015-09-23/umlisp-orf-20150923-git.tgz 31495 401d1d133f874eccafc76426495bdfc6 340233287e9c9c427e2d0260eb2cb457cb494a56 umlisp-orf-20150923-git umlisp-orf.asd
uncursed http://beta.quicklisp.org/archive/uncursed/2022-02-20/uncursed-20220220-git.tgz 24184 5f2e1cdf4479d82fcae29a8e5f3423cc 839eb08169922109aa2b077091243a66db69b5c2 uncursed-20220220-git uncursed-examples.asd uncursed.asd
unicly http://beta.quicklisp.org/archive/unicly/2021-01-24/unicly-20210124-git.tgz 101946 b445da828ba22cad3d94bca17340da95 74a73d2f1507e0bd808aefffa5e7519ccadcdfbb unicly-20210124-git unicly.asd
unit-formula http://beta.quicklisp.org/archive/unit-formula/2018-07-11/unit-formula-20180711-git.tgz 22478 4739cdb264153430300215eec7d8a766 43c9faa30a3d9bf36d81be4df653f66c5104a8c2 unit-formula-20180711-git unit-formulas.asd
unit-test http://beta.quicklisp.org/archive/unit-test/2012-05-20/unit-test-20120520-git.tgz 5026 ffcde1c03dd33862cd4f7288649c3cbc a90ba788826db66fb183ef221a2bd57550d66d51 unit-test-20120520-git unit-test.asd
universal-config http://beta.quicklisp.org/archive/universal-config/2018-04-30/universal-config-20180430-git.tgz 18717 ea3d382afa8904aa76d6e3131c89a1b8 b177d9d562fe68db71f805451e6d7e357647d055 universal-config-20180430-git universal-config.asd
unix-options http://beta.quicklisp.org/archive/unix-options/2015-10-31/unix-options-20151031-git.tgz 11220 3bbdeafbef3e7a2e94b9756bf173f636 64c26167d493cca5c981c1c9a3f923f7406d6e25 unix-options-20151031-git unix-options.asd
unix-opts http://beta.quicklisp.org/archive/unix-opts/2021-01-24/unix-opts-20210124-git.tgz 15695 c75d3233c0f2e16793b1ce19bfc83811 89b779761b8146989d5272ae5323728e86aac92f unix-opts-20210124-git unix-opts.asd
uri-template http://beta.quicklisp.org/archive/uri-template/2019-08-13/uri-template-1.3.1.tgz 20667 2819c38acf5408c90ef2c4f12bfaf73e 42d350f11de6975925bd1aba0878e322836b8817 uri-template-1.3.1 uri-template.asd uri-template.test.asd
url-rewrite http://beta.quicklisp.org/archive/url-rewrite/2017-12-27/url-rewrite-20171227-git.tgz 12733 a27f51e1cd3b62263386c02b07b754b5 16fe74d55e44c734edc7286ac793686150721520 url-rewrite-20171227-git url-rewrite.asd
userial http://beta.quicklisp.org/archive/userial/2011-06-19/userial_0.8.2011.06.02.tgz 25305 18ca2d20cbb483ddb2cb6712387384dc 358b810d26b835ff5a26e1be33aeb6721801d94d userial_0.8.2011.06.02 userial-tests.asd userial.asd
usocket http://beta.quicklisp.org/archive/usocket/2022-11-06/usocket-0.8.5.tgz 91098 82f33c272abd0de3258410e1835ab042 c751b010d65ba5f546b07fda03697e29d1e5789a usocket-0.8.5 usocket-server.asd usocket-test.asd usocket.asd
utilities.binary-dump http://beta.quicklisp.org/archive/utilities.binary-dump/2018-12-10/utilities.binary-dump-20181210-git.tgz 13155 2f2ae5e2669f8d4f3e0bbea638cf473f 437ea86b8f923e9929ffc644beebc1e687433e9f utilities.binary-dump-20181210-git utilities.binary-dump.asd
utilities.print-items http://beta.quicklisp.org/archive/utilities.print-items/2022-11-06/utilities.print-items-20221106-git.tgz 10569 2eb057c82b7144e9773fce16f92a913f 000198d0cae5069612f753003dd532d7c01e9072 utilities.print-items-20221106-git utilities.print-items.asd
utilities.print-tree http://beta.quicklisp.org/archive/utilities.print-tree/2022-11-06/utilities.print-tree-20221106-git.tgz 9697 c7b9a55849256f9960911efc690d50ba 7c09c753cd2a4a298308c973d1fc35c89a911e4e utilities.print-tree-20221106-git utilities.print-tree.asd
utility http://beta.quicklisp.org/archive/utility/2019-02-02/utility-20190202-git.tgz 5158 55e9e5ba352fe19b956af04fa4dc19bc 62360ca825f0bbbbaf2d244698a01cbf75f6e86e utility-20190202-git utility.asd
utility-arguments http://beta.quicklisp.org/archive/utility-arguments/2016-12-04/utility-arguments-20161204-git.tgz 8656 0f60552f326f7164cac4b957e4d48099 9cdfeb9cad7d4e0d84c18ac8f895ce7561bf62e4 utility-arguments-20161204-git utility-arguments.asd
utils-kt http://beta.quicklisp.org/archive/utils-kt/2020-02-18/utils-kt-20200218-git.tgz 17973 888a8505fcd3f9023b4938ed53f700ec 2c82fb87dd2d9c9d1720b22508d7000d5bd13a38 utils-kt-20200218-git utils-kt.asd
utm http://beta.quicklisp.org/archive/utm/2020-02-18/utm-20200218-git.tgz 5366 1c8f9f8ad98c0022b9b606be96156cc3 972d99046777cc8e246357232ac39cb27954e0c1 utm-20200218-git utm.asd utm.test.asd
utm-ups http://beta.quicklisp.org/archive/utm-ups/2021-02-28/utm-ups-20210228-git.tgz 19924 1806dd729202723bea6d746d0569a095 84fcded58f15680b5f71c0fca1b46b119269c7f4 utm-ups-20210228-git utm-ups.asd
uuid http://beta.quicklisp.org/archive/uuid/2020-07-15/uuid-20200715-git.tgz 22210 e550de5e4e0f8cc9dc92aff0b488a991 a68cc19869cbc10c691c967e6355c4fcb58e4f39 uuid-20200715-git uuid.asd
validate-list http://beta.quicklisp.org/archive/validate-list/2021-04-11/validate-list-20210411-git.tgz 11893 d372937ef2299768f6adb55ad6eaabd3 a002d9b7214e0deb8828f88e2bd1d42a19002abc validate-list-20210411-git validate-list.asd
varjo http://beta.quicklisp.org/archive/varjo/2021-01-24/varjo-release-quicklisp-92f9c75b-git.tgz 336707 78a3b8021885ebfab4015e20b885cdcf 5239f7015582f01cf2439a3e001f4417db2dd7b0 varjo-release-quicklisp-92f9c75b-git varjo.asd varjo.import.asd varjo.tests.asd
vas-string-metrics http://beta.quicklisp.org/archive/vas-string-metrics/2021-12-09/vas-string-metrics-20211209-git.tgz 6888 b1264bac0f9516d9617397e1b7a7c20e 4b62b060f1007ba3f686d262c918d18d0682594e vas-string-metrics-20211209-git test.vas-string-metrics.asd vas-string-metrics.asd
vecto http://beta.quicklisp.org/archive/vecto/2021-12-30/vecto-1.6.tgz 71198 9b7f7ddb9cc4d8de353979e339182c31 2818b227789355999efb4a93830c41410902ccb1 vecto-1.6 vecto.asd vectometry/vectometry.asd
vector http://beta.quicklisp.org/archive/vector/2013-01-28/vector-20130128-git.tgz 13555 d00644c19ce7e0d1302acda0bf238081 042f916e4c5c4648ab2b8e2d41f164783563522a vector-20130128-git com.elbeno.vector.asd
vectors http://beta.quicklisp.org/archive/vectors/2017-12-27/vectors-20171227-git.tgz 4968 413caa1cced2681421c9ee3438079a7c a52d5b2e5ff875860d90cd76f8cf63650041e60a vectors-20171227-git vectors.asd
vellum http://beta.quicklisp.org/archive/vellum/2022-11-06/vellum-20221106-git.tgz 104231 54cf90a0802531c8bf95c0a0edf19a6f b6eeb1c83931944e842c12f3fab6b1673899aab3 vellum-20221106-git vellum-tests.asd vellum.asd
vellum-binary http://beta.quicklisp.org/archive/vellum-binary/2022-11-06/vellum-binary-20221106-git.tgz 4082 7bc332aa383565e21cb674b617b7e04a c96ef62607ccaa9d894c474bc650a05f6271f152 vellum-binary-20221106-git vellum-binary.asd
vellum-clim http://beta.quicklisp.org/archive/vellum-clim/2021-05-31/vellum-clim-20210531-git.tgz 1855 9a0f92839445a89d25934dd36ad58e22 0a9a1ee49e530d0fe058420642ad61cc46b0b61c vellum-clim-20210531-git vellum-clim.asd
vellum-csv http://beta.quicklisp.org/archive/vellum-csv/2022-07-07/vellum-csv-20220707-git.tgz 10762 aed5b75011ceee9adbd166795d1e2427 fbc20c998588989beb30bdb7b602e415dc9357fb vellum-csv-20220707-git vellum-csv-tests.asd vellum-csv.asd
vellum-postmodern http://beta.quicklisp.org/archive/vellum-postmodern/2022-11-06/vellum-postmodern-20221106-git.tgz 2548 d927d4c9f1ad3e036470fdcf4e767f42 aba4cd13671b2f65047e9f3f97b51171fe529c55 vellum-postmodern-20221106-git vellum-postmodern.asd
verbose http://beta.quicklisp.org/archive/verbose/2020-12-20/verbose-20201220-git.tgz 61480 5a36b6316092d722acee9570dc590906 6560efa8ae90d4770a205fbbdb77a712563f7212 verbose-20201220-git verbose.asd
verlet http://beta.quicklisp.org/archive/verlet/2021-12-09/verlet-20211209-git.tgz 14694 732b6e14e5ba0fbc79e39f4d44663de2 50600c8260938a374760ffd159e098f6c1505e50 verlet-20211209-git verlet.asd
vernacular http://beta.quicklisp.org/archive/vernacular/2021-10-20/vernacular-20211020-git.tgz 40989 b81a39654d827b44ccc02aae6fb26f5a 58a95976e3513383e09cdbbc14f51d5d20b745a7 vernacular-20211020-git vernacular.asd
verrazano http://beta.quicklisp.org/archive/verrazano/2012-09-09/verrazano-20120909-darcs.tgz 154093 fdb516677e8414b3400fd8dd6f91817b 3dfe039d928da642c40544b7418fcc8929a43dae verrazano-20120909-darcs verrazano-runtime.asd verrazano.asd
vertex http://beta.quicklisp.org/archive/vertex/2015-06-08/vertex-20150608-git.tgz 3549 f0e1a725b6733155306c4dd9d8245ea8 27473fcccbf03bd3a904a3c0d04b8c40413c514d vertex-20150608-git vertex-test.asd vertex.asd
vgplot http://beta.quicklisp.org/archive/vgplot/2022-07-07/vgplot-20220707-git.tgz 34852 501191985751a7b3eb226523d520ad8b 3888bedc247581be80f39e188cf76c0aca98d1bb vgplot-20220707-git vgplot.asd
vivid-colors http://beta.quicklisp.org/archive/vivid-colors/2022-07-07/vivid-colors-20220707-git.tgz 101674 8bae78831d589ffac9781efdd9f71fb2 d95a25c2ffae22d52aafa6587336d8fe7b5f071e vivid-colors-20220707-git content/spec/vivid-colors.content.test.asd content/vivid-colors.content.asd dispatch/spec/vivid-colors.dispatch.test.asd dispatch/vivid-colors.dispatch.asd queue/spec/vivid-colors.queue.test.asd queue/vivid-colors.queue.asd shared/spec/vivid-colors.shared.test.asd shared/vivid-colors.shared.asd spec/vivid-colors.test.asd stream/spec/vivid-colors.stream.test.asd stream/vivid-colors.stream.asd vivid-colors.asd
vivid-diff http://beta.quicklisp.org/archive/vivid-diff/2022-07-07/vivid-diff-20220707-git.tgz 25712 d8380d738d71b282b9610aae91b08b0f 15ba7bf5ae869a397988730b423a3bfd9cdfaa0b vivid-diff-20220707-git spec/vivid-diff.test.asd vivid-diff.asd
vk http://beta.quicklisp.org/archive/vk/2022-11-06/vk-20221106-git.tgz 631681 7028de7e3c56db844ccfd0b08202977c a5e658b2f02b40ee274c8051d07d929c62ba35ec vk-20221106-git vk.asd
vom http://beta.quicklisp.org/archive/vom/2016-08-25/vom-20160825-git.tgz 4286 ad16bdc0221b08de371be6ce25ce3d47 4618a41b412c27f8a543c70bef09b49d68d9b1f7 vom-20160825-git vom.asd
vom-json http://beta.quicklisp.org/archive/vom-json/2020-06-10/vom-json-20200610-git.tgz 5506 bf4c4f9418c91b8ff0a0b722aac2b335 5e740ae88b867216b8408e31eaee3f47f29ea45d vom-json-20200610-git vom-json.asd
vp-trees http://beta.quicklisp.org/archive/vp-trees/2020-12-20/vp-trees-20201220-git.tgz 4820 7f2ad883e5ee60ac2a33ba010a2f6d43 b8c04d60e0e9bbcde33ec7ed77907f954b9afc19 vp-trees-20201220-git vp-trees.asd
wallstreetflets http://beta.quicklisp.org/archive/wallstreetflets/2021-12-09/wallstreetflets-20211209-git.tgz 15177 06a0c728903eefec1deb052011bdae3a dc4cdfa394328df1acb6b957ab27f97a779e7589 wallstreetflets-20211209-git wallstreetflets.asd
wasm-encoder http://beta.quicklisp.org/archive/wasm-encoder/2021-06-30/wasm-encoder-20210630-git.tgz 25736 92965e08a87bf5a6dcb438f3a22e9b5f 7138aa2ec824afc3ca306b060d28ab815a9cf78d wasm-encoder-20210630-git wasm-encoder.asd
water http://beta.quicklisp.org/archive/water/2019-01-07/water-20190107-git.tgz 2387 8340d15004bc9b07d822eb08d73846d7 679bc44d0f73f8963f5ced8211c3abd45e7cb8b8 water-20190107-git water.asd
wayflan http://beta.quicklisp.org/archive/wayflan/2022-11-06/wayflan-20221106-git.tgz 615527 7d5f72c7d7cb2586feaa56466fb0b53b 98963d882c0e92a585a5d3b7ad0203b380ba03ed wayflan-20221106-git wayflan-client.asd wayflan.asd
webapi http://beta.quicklisp.org/archive/webapi/2021-10-20/webapi-20211020-git.tgz 4232 8ed6e60719474dafa3b74acb93b9d612 a2cc4307f83ba5742e799368f3a399bf1415b4c1 webapi-20211020-git webapi.asd
weblocks http://beta.quicklisp.org/archive/weblocks/2021-10-20/weblocks-20211020-git.tgz 312633 1f465c9ae7627a319e5838ea57198cbb e416f64744e54eb0e7cb6e199c09d3b797ea21b3 weblocks-20211020-git weblocks-scripts.asd weblocks-util.asd
weblocks-stores http://beta.quicklisp.org/archive/weblocks-stores/2021-10-20/weblocks-stores-20211020-git.tgz 24830 e63774086fe46ff8b5d43b63b5e1b379 55f2582051f6490ec3e505ddc8c81edb063794c8 weblocks-stores-20211020-git src/store/clsql/weblocks-clsql.asd src/store/memory/weblocks-memory.asd src/store/montezuma/weblocks-montezuma.asd src/store/perec/weblocks-perec.asd src/store/prevalence/weblocks-prevalence.asd weblocks-stores.asd
websocket-driver http://beta.quicklisp.org/archive/websocket-driver/2022-03-31/websocket-driver-20220331-git.tgz 11621 d97de4dccbbac21858568a8e47cb9eef 95f5cecd275a3c490ddd2a3ce69399e198114b67 websocket-driver-20220331-git websocket-driver-base.asd websocket-driver-client.asd websocket-driver-server.asd websocket-driver.asd
weft http://beta.quicklisp.org/archive/weft/2018-02-28/weft-20180228-git.tgz 6282 ec7196f159294035d3c06b5723920058 d9ea5ff22d830c1f0deb6fd047e4b62ec280c74c weft-20180228-git weft.asd
westbrook http://beta.quicklisp.org/archive/westbrook/2018-01-31/westbrook-20180131-git.tgz 3249 43e514336921135f6fc3c1b3063eaf4b 97ed8af62728b92027a7321387a64b918475ca7c westbrook-20180131-git westbrook-tests.asd westbrook.asd
what3words http://beta.quicklisp.org/archive/what3words/2016-12-04/what3words-20161204-git.tgz 5600 54303b21497ffca394575c7376c8b9f3 7b37b1c4c32ab419d4f07cf6f1798f4a0b69b88f what3words-20161204-git what3words.asd
which http://beta.quicklisp.org/archive/which/2016-04-21/which-20160421-git.tgz 2063 d352101dca7f6e985c0e437bcdb6fe40 528a7fdbb3c1485e5685145fd0023ece6a9b32c5 which-20160421-git which-test.asd which.asd
whirlog http://beta.quicklisp.org/archive/whirlog/2021-10-20/whirlog-20211020-git.tgz 30872 ab973d92af617b99d4604299c0192b87 d46b878157f360b5e63fb6b2fa6699d2a4cfeba4 whirlog-20211020-git whirlog.asd
whofields http://beta.quicklisp.org/archive/whofields/2021-10-20/whofields-20211020-git.tgz 5394 0b6b7b116a6ce9ba6c7ddcb1abfa5e33 520ef39d46eed4734d891be27a44fadd80b54ae4 whofields-20211020-git whofields.asd
wild-package-inferred-system http://beta.quicklisp.org/archive/wild-package-inferred-system/2021-05-31/wild-package-inferred-system-20210531-git.tgz 9674 4744e08ef5f50da04a429ae9af60bb80 6e8706a7d2208983ccf0d553ed201b9efb893b59 wild-package-inferred-system-20210531-git test/foo-wild/foo-wild.asd wild-package-inferred-system.asd
winhttp http://beta.quicklisp.org/archive/winhttp/2020-06-10/winhttp-20200610-git.tgz 15445 d241af100e613f3b24a800f35ed94944 e93d35b56fbd44ae4ea39074038776bf1b758b4a winhttp-20200610-git winhttp.asd
winlock http://beta.quicklisp.org/archive/winlock/2019-11-30/winlock-20191130-git.tgz 3577 f637484323c2b64fc680325bcadef786 fc646ddf5184afcbf5c84370b68087120a63e7bd winlock-20191130-git winlock.asd
with-branching http://beta.quicklisp.org/archive/with-branching/2022-02-20/with-branching-20220220-git.tgz 4777 c3c309a6a2516caca19c28ec328d179a a08cb95c337195815be41800681f950f9a362861 with-branching-20220220-git with-branching.asd
with-c-syntax http://beta.quicklisp.org/archive/with-c-syntax/2022-11-06/with-c-syntax-20221106-git.tgz 110532 c8a73f50e07291a5642ea6b7a7ff7cfb db736696ac722f7a0269ec50672995bafc897285 with-c-syntax-20221106-git with-c-syntax-test.asd with-c-syntax.asd
with-cached-reader-conditionals http://beta.quicklisp.org/archive/with-cached-reader-conditionals/2017-06-30/with-cached-reader-conditionals-20170630-git.tgz 2457 16049564ecfdb5a6db9edd1bdcf0a921 4be7101d32ea9f59c716ce5b822a58e0bb124a05 with-cached-reader-conditionals-20170630-git with-cached-reader-conditionals.asd
with-contexts http://beta.quicklisp.org/archive/with-contexts/2022-02-20/with-contexts-20220220-git.tgz 27938 b93802fbcf6616111f51fc293ba83caa 4bdbc652b9f8e17dec5c2542a686e166424768f7 with-contexts-20220220-git with-contexts.asd
with-output-to-stream http://beta.quicklisp.org/archive/with-output-to-stream/2019-10-07/with-output-to-stream_1.0.tgz 4266 d9bee5027d6c04bcd7f63f4c48706f5c a3b23295277552cf9dd81191edd50ed8019a1c67 with-output-to-stream_1.0 tests/with-output-to-stream_tests.asd with-output-to-stream.asd
with-setf http://beta.quicklisp.org/archive/with-setf/2018-02-28/with-setf-release-quicklisp-df3eed9d-git.tgz 2558 9218b3765e9e2fd26a7f103e63fc89fe a6db3e7df0bb1b289e2134d8668be0ff51b4389e with-setf-release-quicklisp-df3eed9d-git with-setf.asd
with-shadowed-bindings http://beta.quicklisp.org/archive/with-shadowed-bindings/2019-01-07/with-shadowed-bindings-1.0.tgz 5127 1f583c77f5d2c67c934ab33d2ba810c3 a786cd36c9aee7348f63f7d6fe482225a728ccb2 with-shadowed-bindings-1.0 tests/with-shadowed-bindings_tests.asd with-shadowed-bindings.asd
with-user-abort http://beta.quicklisp.org/archive/with-user-abort/2021-04-11/with-user-abort-20210411-git.tgz 1039 20cda05e4ec16ebd956096c2c88482f0 ab4043fcdb8735f97a17a243deb9936ac6eaae81 with-user-abort-20210411-git with-user-abort.asd
woo http://beta.quicklisp.org/archive/woo/2022-07-07/woo-20220707-git.tgz 225778 64a9cd4acc9fc520605dd3cf86912570 556b56ab637c54203db969f865a905dcf9904d4a woo-20220707-git clack-handler-woo.asd woo-test.asd woo.asd
wookie http://beta.quicklisp.org/archive/wookie/2019-11-30/wookie-20191130-git.tgz 29738 5e5d6537637312919fd528bb1d0c1eba 660d6b8277d9bc3a82aeb0db51bb2d51e71a3678 wookie-20191130-git wookie.asd
wordnet http://beta.quicklisp.org/archive/wordnet/2022-02-20/wordnet-20220220-git.tgz 10485176 7e7552e61d3e9578498038cbb2e4e604 1c098b7dc2bd5c40c74764454e2a830368f8ee9d wordnet-20220220-git wordnet.asd
workout-timer http://beta.quicklisp.org/archive/workout-timer/2022-07-07/workout-timer-20220707-git.tgz 319836 e2959f5c433a33b49d7b11b2d4e7b2e5 f8829a476483a1effefdc5a55fad8e74037e0807 workout-timer-20220707-git workout-timer.asd
wu-decimal http://beta.quicklisp.org/archive/wu-decimal/2013-01-28/wu-decimal-20130128-git.tgz 6244 e0676ea5ba7ce65e4d80cc5128c1e668 b37c145557a1b9541f9219629c1091976dc2656f wu-decimal-20130128-git wu-decimal.asd
wu-sugar http://beta.quicklisp.org/archive/wu-sugar/2016-08-25/wu-sugar-20160825-git.tgz 3555 ef7aec6772cda55c04bf117a2a8cb4ac a2dde559d7e28bdaa93dfcf0e1f080447873c9d3 wu-sugar-20160825-git wu-sugar.asd
wuwei http://beta.quicklisp.org/archive/wuwei/2022-11-06/wuwei-20221106-git.tgz 150962 d4ad66b127b1913278003f6ac3678dee 96984d473bbdb701116765069a680d473b13b6b4 wuwei-20221106-git wuwei.asd
x.let-star http://beta.quicklisp.org/archive/x.let-star/2020-03-25/x.let-star-20200325-git.tgz 7940 c6984b5a4e60a3a88d088ebe69e840b0 c66f72bf9b9e42964818dcc75c322203a262c52b x.let-star-20200325-git x.let-star.asd
xarray http://beta.quicklisp.org/archive/xarray/2014-01-13/xarray-20140113-git.tgz 26181 477bb421f87f6de0236065bf81949a32 5466b0687c3ac4a6466d2761b9d29510658785bb xarray-20140113-git xarray-test.asd xarray.asd
xcat http://beta.quicklisp.org/archive/xcat/2020-09-25/xcat-20200925-git.tgz 7671 ae0f3e8c401266ef9a56245b4021112f 2ca9c1cd50d20186d605ecb9a3ebd451ff5744cf xcat-20200925-git xcat.asd
xecto http://beta.quicklisp.org/archive/xecto/2015-12-18/xecto-20151218-git.tgz 29803 f770596c9d7a9ce86fb2d7952bc9e40e 489a3f39048451dfaab304a73681d5f8ce779a8b xecto-20151218-git xecto.asd
xhtmlambda http://beta.quicklisp.org/archive/xhtmlambda/2022-02-20/xhtmlambda-20220220-git.tgz 54372 81e2242f6da5020a4249cea7fbbfe2ba b859d6de248837cd05828fadaccfb1d1a83c3fcf xhtmlambda-20220220-git xhtmlambda.asd
xhtmlgen http://beta.quicklisp.org/archive/xhtmlgen/2017-01-24/xhtmlgen-20170124-git.tgz 4264 17fc90eab99b1fb0cf6335065e84c109 bbb503e316f419d7cffb2f3f648e0227bc61cb15 xhtmlgen-20170124-git xhtmlgen.asd
xlsx http://beta.quicklisp.org/archive/xlsx/2018-07-11/xlsx-20180711-git.tgz 3050 10133595e8973f9acdd0301c00d04f8c 5a5dc8579c348ffae3625fbb088aa4ee008e3eaf xlsx-20180711-git xlsx.asd
xlunit http://beta.quicklisp.org/archive/xlunit/2015-09-23/xlunit-20150923-git.tgz 9484 1c673862f57e998c7a7b8e74de0d0c92 de0142632a8227f339178055eb5543a0c8dce789 xlunit-20150923-git xlunit.asd
xml-emitter http://beta.quicklisp.org/archive/xml-emitter/2022-11-06/xml-emitter-20221106-git.tgz 8095 085c162bbb17fc1712a5efe0e458c807 bfa1afd67b37010f0db07630974bf396d82cee5b xml-emitter-20221106-git xml-emitter.asd
xml-mop http://beta.quicklisp.org/archive/xml-mop/2011-04-18/xml-mop-20110418-git.tgz 15391 028fde76c0d121865cb5167962a4b78b f5fb4a43a2defedb352b072be94d4c22f433dfc3 xml-mop-20110418-git xml-mop.asd
xml.location http://beta.quicklisp.org/archive/xml.location/2020-03-25/xml.location-20200325-git.tgz 31507 90cf4fd2450ba562c7f9657391dacb1d e8ac43311d5a362c9e39e5e52fc46b1df2bc11ef xml.location-20200325-git xml.location-and-local-time.asd xml.location.asd
xmls http://beta.quicklisp.org/archive/xmls/2022-07-07/xmls-release-c6ca1b39-git.tgz 116932 ef2cf297230d1a1f8a09abf6c7f40bad f2bfe7b8b7b140b7fc748b4c2a40f888d21bdf56 xmls-release-c6ca1b39-git xmls.asd
xptest http://beta.quicklisp.org/archive/xptest/2015-09-23/xptest-20150923-git.tgz 6874 61f6ff5cc44cf8da5d8036084a31fbc3 09eebbc1fa611a9b628c9d2de12f6c81bf4420b8 xptest-20150923-git xptest.asd
xsubseq http://beta.quicklisp.org/archive/xsubseq/2017-08-30/xsubseq-20170830-git.tgz 4006 960bb8f329649b6e4b820e065e6b38e8 77ef22871e590349e22e892cd8f80121db1b1566 xsubseq-20170830-git xsubseq-test.asd xsubseq.asd
xuriella http://beta.quicklisp.org/archive/xuriella/2012-03-05/xuriella-20120305-git.tgz 122204 55eb6e13da338bc47b640a2767b0bd20 49899b4682e3a72322c69feb21ced8a109675833 xuriella-20120305-git xuriella.asd
yaclml http://beta.quicklisp.org/archive/yaclml/2018-01-31/yaclml-20180131-git.tgz 32006 b3dba0cd334aef4fc75b465b2b31a94a 76172119d82a08b4483721cc6746228c8d9b8079 yaclml-20180131-git yaclml.asd
yah http://beta.quicklisp.org/archive/yah/2022-11-06/yah-20221106-git.tgz 2382 c29c4a87ce3e1e7ccb78a4d744d2fa1d 24efb0eed6a734713b5d266408e1ec58c589e63b yah-20221106-git yah.asd
yason http://beta.quicklisp.org/archive/yason/2022-11-06/yason-20221106-git.tgz 30747 da3721b69bdf923b7e387ac588c2af10 9f4117507bcb48ae0023bc6d3c788fa1afa6cb89 yason-20221106-git yason.asd
youtube http://beta.quicklisp.org/archive/youtube/2019-12-27/youtube-20191227-git.tgz 3054 36af0a0118f51e4e57d1dee28f720a44 dc8b73c9c8d14ba29827baf8ef5bda3b0a25d275 youtube-20191227-git youtube.asd
zacl http://beta.quicklisp.org/archive/zacl/2021-08-07/zacl-20210807-git.tgz 22798 c1ab72503b3a9f0bb67bc902369ab23e 20e90bef77d393419cdf08528be2183b25b4dd1c zacl-20210807-git zacl.asd
zaws http://beta.quicklisp.org/archive/zaws/2015-04-07/zaws-20150407-git.tgz 13832 13ada144680e2f5d111df8f0a0217d99 8d181469163fac8b77280c98c5ab28ca7098fe4b zaws-20150407-git xml/zaws-xml.asd zaws.asd
zbucium http://beta.quicklisp.org/archive/zbucium/2019-07-10/zbucium-20190710-git.tgz 4503 90b10e33e3fa82d42174016881d557bc d0e1df0c25eb87e1e0e66af27fd2dac5b20c7fb4 zbucium-20190710-git zbucium.asd
zcdb http://beta.quicklisp.org/archive/zcdb/2015-04-07/zcdb-1.0.4.tgz 7393 e924c2b419f9875364cd662184fc55d1 db5f7a8e8a22f858794b64ef255f7dea015835f8 zcdb-1.0.4 zcdb.asd
zenekindarl http://beta.quicklisp.org/archive/zenekindarl/2017-11-30/zenekindarl-20171130-git.tgz 17395 2c8e9002b6434d92761ced8e187c5903 0a732633d8173828feec7a8b5eaab103de638e7f zenekindarl-20171130-git zenekindarl-test.asd zenekindarl.asd
zip http://beta.quicklisp.org/archive/zip/2015-06-08/zip-20150608-git.tgz 20940 5be194863779dcbd3c83e07524392f14 a8fa33dc2a19df78942e02c0e35a78f054992bd7 zip-20150608-git zip.asd
zippy http://beta.quicklisp.org/archive/zippy/2022-11-06/zippy-20221106-git.tgz 101220 256d4b5d923d62de2b9cb7b30dbd4011 3caca7ff031b231fe213962b69a53b2404eccde4 zippy-20221106-git zippy-dwim.asd zippy.asd
ziz http://beta.quicklisp.org/archive/ziz/2019-10-07/ziz-20191007-git.tgz 3184 24b32be09b15855c77b6fddc2d6d6ea3 f9d30703cd655564a12063a77b466930cd52a41d ziz-20191007-git ziz.asd
zlib http://beta.quicklisp.org/archive/zlib/2017-04-03/zlib-20170403-git.tgz 9104 67450036249df47288f4a8330ea28f57 498b41ab3e46c63d5f0ae3ece8eeb47c95009bad zlib-20170403-git zlib.asd
zpb-exif http://beta.quicklisp.org/archive/zpb-exif/2021-01-24/zpb-exif-release-1.2.5.tgz 14751 195389d99058243d1022f2c31facf0e7 bef28435ef937710fad945636aae240d5b236fe7 zpb-exif-release-1.2.5 zpb-exif.asd
zpb-ttf http://beta.quicklisp.org/archive/zpb-ttf/2021-01-24/zpb-ttf-release-1.0.4.tgz 45564 b66f67b0a1fc347657d4d71ddb304920 689de6a6535a6a5a005039c7f2d2248f41ef2ccb zpb-ttf-release-1.0.4 zpb-ttf.asd
zpng http://beta.quicklisp.org/archive/zpng/2015-04-07/zpng-1.2.2.tgz 40141 0a208f4ce0087ef578d477341d5f4078 0374a5e03f266152dea01c6fff9839798725697c zpng-1.2.2 zpng.asd
zs3 http://beta.quicklisp.org/archive/zs3/2019-10-07/zs3-1.3.3.tgz 57149 5ea13aa7a490758882e245c3f8bb063e 8b3bcc4f7a524ca09f3b6fa6600c510e1f2d9e3b zs3-1.3.3 zs3.asd
zsort http://beta.quicklisp.org/archive/zsort/2012-05-20/zsort-20120520-git.tgz 6259 08689032aed3f283c9ab84b536d0aca3 5b8b68c44983d394a8328f30cdc2b8fb6c96331a zsort-20120520-git zsort.asd
| 539,973 | Common Lisp | .l | 2,219 | 242.340694 | 15,181 | 0.867233 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 268a2b9efc9d0f9c8403ccb1eb08f6141a1ccf7bd1a9d4748842fec648bd1950 | 43,191 | [
-1
] |
43,195 | .travis.yml | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/babel-20200925-git/.travis.yml | language: lisp
env:
matrix:
- LISP=abcl
- LISP=allegro
- LISP=sbcl
- LISP=sbcl32
- LISP=ccl
- LISP=ccl32
- LISP=clisp
- LISP=clisp32
- LISP=cmucl
- LISP=ecl
matrix:
allow_failures:
- env: LISP=cmucl
- env: LISP=ecl
install:
- curl -L https://github.com/luismbo/cl-travis/raw/master/install.sh | sh
- git clone --depth=1 git://github.com/trivial-features/trivial-features.git ~/lisp/trivial-features
- git clone https://gitlab.common-lisp.net/alexandria/alexandria.git ~/lisp/alexandria
script:
- cl -e '(ql:quickload :babel-tests)
(unless (babel-tests:run)
(uiop:quit 1))'
sudo: required
| 677 | Common Lisp | .l | 26 | 21.615385 | 102 | 0.664087 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 6c7de47f97a18e4cf1e68ae80eb377195ead9100704093331855353c1a723eda | 43,195 | [
-1
] |
43,231 | clixdoc.xsl | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/docs/clixdoc.xsl | <?xml version="1.0" encoding="iso-8859-1" ?>
<!--
;;; Copyright (c) 2008, Hans Hübner. All rights reserved.
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-->
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0"
xmlns:clix="http://bknr.net/clixdoc"
exclude-result-prefixes="clix">
<xsl:output method="html"
indent="yes"
omit-xml-declaration="yes"
doctype-public="-//W3C//DTD HTML 4.0 Strict//EN" />
<xsl:key name="index-entries" match="clix:*[@name and (name() != 'clix:chapter') and (name() != 'clix:subchapter')]" use="@name" />
<xsl:template match="/clix:documentation">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title><xsl:value-of select="clix:title"/></title>
<meta name="description"><xsl:attribute name="content"><xsl:value-of select="clix:short-description"/></xsl:attribute></meta>
<style type="text/css">
body { background-color: #ffffff }
pre { padding:5px; background-color:#e0e0e0 }
pre.none { padding:5px; background-color:#ffffff }
h3, h4, h5 { text-decoration: underline; }
.entry-type { padding-left: 1em; font-size: 60%; font-style: italic }
a { text-decoration: none; padding: 1px 2px 1px 2px; }
a:visited { text-decoration: none; padding: 1px 2px 1px 2px; }
a:hover { text-decoration: none; padding: 1px 1px 1px 1px; border: 1px solid #000000; }
a:focus { text-decoration: none; padding: 1px 2px 1px 2px; border: none; }
a.none { text-decoration: none; padding: 0; }
a.none:visited { text-decoration: none; padding: 0; }
a.none:hover { text-decoration: none; border: none; padding: 0; }
a.none:focus { text-decoration: none; border: none; padding: 0; }
a.noborder { text-decoration: none; padding: 0; }
a.noborder:visited { text-decoration: none; padding: 0; }
a.noborder:hover { text-decoration: none; border: none; padding: 0; }
a.noborder:focus { text-decoration: none; border: none; padding: 0; }
</style>
</head>
<body>
<xsl:apply-templates/>
</body>
</html>
</xsl:template>
<xsl:template match="clix:library-version">
<xsl:value-of select="$library-version"/>
</xsl:template>
<xsl:template match="clix:title"/>
<xsl:template match="clix:short-description"/>
<xsl:template match="clix:function">
<p>
<xsl:call-template name="make-anchor"/>
<xsl:choose>
<xsl:when test="clix:special-definition">
<xsl:apply-templates select="clix:special-definition"/>
</xsl:when>
<xsl:otherwise>
[<xsl:call-template name="nice-entry-type-name"/>]
<br/>
<xsl:call-template name="render-title"/>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i>
<xsl:if test="clix:returns">
=>
<i><xsl:apply-templates select="clix:returns"/></i>
</xsl:if>
</xsl:otherwise>
</xsl:choose>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:reader">
<p>
<xsl:call-template name="make-anchor"/>
[<xsl:call-template name="nice-entry-type-name"/>]
<br/>
<xsl:call-template name="render-title"/>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i>
<xsl:if test="clix:returns">
=>
<i><xsl:apply-templates select="clix:returns"/></i>
</xsl:if>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:listed-reader">
<xsl:call-template name="make-anchor"/>
<xsl:call-template name="render-title"/>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i>
<xsl:if test="clix:returns">
=>
<i><xsl:apply-templates select="clix:returns"/></i>
</xsl:if>
<br/>
</xsl:template>
<xsl:template match="clix:writer">
<p>
<xsl:call-template name="make-anchor"/>
[<xsl:call-template name="nice-entry-type-name"/>]
<br/>
<tt>(setf (</tt><b><xsl:value-of select="@name"/></b>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i><tt>) <i>new-value</i>)</tt>
<xsl:if test="clix:returns">
=>
<i><xsl:apply-templates select="clix:returns"/></i>
</xsl:if>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:accessor">
<p>
<xsl:call-template name="make-anchor"/>
[<xsl:call-template name="nice-entry-type-name"/>]
<br/>
<xsl:call-template name="render-title"/>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i>
=>
<i><xsl:apply-templates select="clix:returns"/></i>
<br/>
<tt>(setf (</tt><b><xsl:value-of select="@name"/></b>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i><tt>) <i>new-value</i>)</tt>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:listed-accessor">
<xsl:call-template name="make-anchor"/>
<xsl:call-template name="render-title"/>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i>
=>
<i><xsl:apply-templates select="clix:returns"/></i>
<br/>
<tt>(setf (</tt><b><xsl:value-of select="@name"/></b>
<xsl:value-of select="' '"/>
<i><xsl:apply-templates select="clix:lambda-list"/></i><tt>) <i>new-value</i>)</tt>
<br/>
</xsl:template>
<xsl:template match="clix:special-variable | clix:class | clix:condition | clix:symbol | clix:constant">
<p>
<xsl:call-template name="make-anchor"/>
[<xsl:call-template name="nice-entry-type-name"/>]
<br/>
<xsl:call-template name="render-title"/>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:listed-constant">
<xsl:call-template name="render-title"/>
<br/>
</xsl:template>
<xsl:template match="clix:constants">
<!-- Display a list of constants with a common description -->
<p>
[Constants]<br/>
<xsl:apply-templates select="clix:listed-constant"/>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:readers">
<!-- Display a list of readers with a common description -->
<p>
[<xsl:call-template name="nice-entry-type-name"/>]<br/>
<xsl:apply-templates select="clix:listed-reader"/>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:accessors">
<!-- Display a list of accessors with a common description -->
<p>
[<xsl:call-template name="nice-entry-type-name"/>]<br/>
<xsl:apply-templates select="clix:listed-accessor"/>
<blockquote>
<xsl:apply-templates select="clix:description"/>
</blockquote>
</p>
</xsl:template>
<xsl:template match="clix:qualifier">
<!-- method qualifier -->
<tt><xsl:value-of select="text()"/></tt>
</xsl:template>
<xsl:template match="clix:lkw">
<!-- lambda list keyword -->
<tt>&<xsl:value-of select="text()"/></tt>
</xsl:template>
<xsl:template match="clix:arg">
<!-- argument reference -->
<code><i><xsl:value-of select="text()"/></i></code>
</xsl:template>
<xsl:template match="clix:ref">
<xsl:call-template name="internal-reference">
<xsl:with-param name="name"><xsl:value-of select="."/></xsl:with-param>
</xsl:call-template>
</xsl:template>
<xsl:template match="clix:chapter">
<h3>
<a class="none">
<xsl:attribute name="name"><xsl:value-of select="@name"/></xsl:attribute>
<xsl:value-of select="@title"/>
</a>
</h3>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="clix:subchapter">
<h4>
<a>
<xsl:attribute name="name"><xsl:value-of select="@name"/></xsl:attribute>
<xsl:value-of select="@title"/>
</a>
</h4>
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="clix:contents">
<ol>
<xsl:for-each select="//clix:chapter">
<li>
<a>
<xsl:attribute name="href">#<xsl:value-of select="@name"/></xsl:attribute>
<xsl:value-of select="@title"/>
</a>
<xsl:if test="clix:subchapter">
<ol>
<xsl:for-each select="clix:subchapter">
<li>
<a>
<xsl:attribute name="href">#<xsl:value-of select="@name"/></xsl:attribute>
<xsl:value-of select="@title"/>
</a>
</li>
</xsl:for-each>
</ol>
</xsl:if>
</li>
</xsl:for-each>
</ol>
</xsl:template>
<xsl:template match="clix:index">
<ul>
<xsl:for-each select="//clix:*[generate-id(.) = generate-id(key('index-entries', @name)[1])]">
<xsl:sort select="@name"/>
<li>
<xsl:choose>
<xsl:when test="count(key('index-entries', @name)) = 1">
<xsl:call-template name="internal-reference">
<xsl:with-param name="name"><xsl:value-of select="@name"/></xsl:with-param>
</xsl:call-template>
<span class="entry-type"><xsl:call-template name="nice-entry-type-name"/></span>
</xsl:when>
<xsl:otherwise>
<a>
<xsl:attribute name="name">
<xsl:value-of select="@name"/>
</xsl:attribute>
</a>
<xsl:value-of select="@name"/>
<ul>
<xsl:for-each select="key('index-entries', @name)">
<xsl:sort select="name()"/>
<li>
<xsl:call-template name="internal-reference">
<xsl:with-param name="name"><xsl:call-template name="make-anchor-name"/></xsl:with-param>
<xsl:with-param name="title"><xsl:value-of select="@name"/></xsl:with-param>
</xsl:call-template>
<span class="entry-type"><xsl:call-template name="nice-entry-type-name"/></span>
</li>
</xsl:for-each>
</ul>
</xsl:otherwise>
</xsl:choose>
</li>
</xsl:for-each>
</ul>
</xsl:template>
<xsl:template match="*">
<xsl:copy>
<xsl:copy-of select="@*[not(namespace-uri())]"/>
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>
<xsl:template name="internal-reference">
<!-- internal reference -->
<xsl:param name="name"/>
<xsl:param name="title"/>
<code>
<a>
<xsl:attribute name="href">
#<xsl:value-of select="translate($name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>
</xsl:attribute>
<xsl:choose>
<xsl:when test="$title != ''">
<xsl:value-of select="$title"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="$name"/>
</xsl:otherwise>
</xsl:choose>
</a>
</code>
</xsl:template>
<xsl:template name="make-anchor-name">
<xsl:choose>
<xsl:when test="count(key('index-entries', @name)) = 1">
<xsl:value-of select="translate(@name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="translate(@name, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>-<xsl:value-of select="substring(name(), 6)"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template name="make-anchor">
<a class="none">
<xsl:attribute name="name">
<xsl:call-template name="make-anchor-name"/>
</xsl:attribute>
</a>
</xsl:template>
<xsl:template name="render-title">
<b><xsl:value-of select="@name"/></b>
</xsl:template>
<xsl:template name="nice-entry-type-name">
<xsl:choose>
<xsl:when test="name() = 'clix:function'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic function</xsl:when>
<xsl:when test="@specialized = 'true'">Method</xsl:when>
<xsl:when test="@macro = 'true'">Macro</xsl:when>
<xsl:otherwise>Function</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:reader'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic reader</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized reader</xsl:when>
<xsl:otherwise>Reader</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:listed-reader'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic reader</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized reader</xsl:when>
<xsl:otherwise>Reader</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:readers'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic readers</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized readers</xsl:when>
<xsl:otherwise>Readers</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:accessors'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic accessors</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized accessors</xsl:when>
<xsl:otherwise>Accessors</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:writer'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic writer</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized writer</xsl:when>
<xsl:otherwise>Writer</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:listed-accessor'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic accessor</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized accessor</xsl:when>
<xsl:otherwise>Accessor</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:accessor'">
<xsl:choose>
<xsl:when test="@generic = 'true'">Generic accessor</xsl:when>
<xsl:when test="@specialized = 'true'">Specialized accessor</xsl:when>
<xsl:otherwise>Accessor</xsl:otherwise>
</xsl:choose>
</xsl:when>
<xsl:when test="name() = 'clix:special-variable'">Special variable</xsl:when>
<xsl:when test="name() = 'clix:class'">Standard class</xsl:when>
<xsl:when test="name() = 'clix:condition'">Condition type</xsl:when>
<xsl:when test="name() = 'clix:symbol'">Symbol</xsl:when>
<xsl:when test="name() = 'clix:constant'">Constant</xsl:when>
<xsl:when test="name() = 'clix:listed-constant'">Constant</xsl:when>
<xsl:otherwise>
<xsl:value-of select="name()" />
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
| 16,989 | Common Lisp | .l | 429 | 32.200466 | 155 | 0.597168 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | cdca48f5b80ee5401f8aac8a450e943ec07faa35d39235127ad6b97ab3e61cce | 43,231 | [
-1
] |
43,232 | Makefile | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/docs/Makefile |
all:
xsltproc --stringparam library-version `perl -ne 'print "$$1\n" if (/:version "(.*)"/)' ../drakma.asd` clixdoc.xsl index.xml > index.html
| 145 | Common Lisp | .l | 2 | 70.5 | 138 | 0.661972 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 9c6ce25fbb4bd4c3a77aa9cce410ac28e4eeb41edbaee59ea90e81ec2ebff5a3 | 43,232 | [
-1
] |
43,233 | index.xml | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/docs/index.xml | <?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="clixdoc.xsl" ?>
<clix:documentation xmlns='http://www.w3.org/1999/xhtml' xmlns:clix='http://bknr.net/clixdoc'>
<clix:title>Drakma - A Common Lisp HTTP client</clix:title>
<clix:short-description>
Drakma is a full-featured HTTP client implemented in Common Lisp.
It knows how to handle <a href="#chunked">HTTP/1.1 chunking</a>,
<a href="#arg-keep-alive">persistent connections</a>, <a
href="#ex-reuse-connection">re-usable sockets</a>, <a
href="#ex-chunked-https">SSL</a>, <a
href="#ex-assemble-request-content">continuable uploads</a>, <a
href="#arg-parameters">file uploads</a>, <a
href="#arg-cookie-jar">cookies</a>, and more.
</clix:short-description>
<h2>Drakma - A Common Lisp HTTP client</h2>
<blockquote>
<clix:chapter name='abstract' title='Abstract'>
<p>
Drakma is a full-featured HTTP client implemented in Common
Lisp. It knows how to handle <a href="#chunked">HTTP/1.1
chunking</a>, <a href="#arg-keep-alive">persistent
connections</a>, <a href="#ex-reuse-connection">re-usable
sockets</a>, <a href="#ex-chunked-https">SSL</a>, <a
href="#ex-assemble-request-content">continuable uploads</a>,
<a href="#arg-parameters">file uploads</a>, <a
href="#arg-cookie-jar">cookies</a>, and more.
</p>
<p>
The code comes with a <a
href="http://www.opensource.org/licenses/bsd-license.php">BSD-style
license</a> so you can basically do with it whatever you want.
</p>
</clix:chapter>
</blockquote>
<clix:chapter name='contents' title='Contents'></clix:chapter>
<clix:contents></clix:contents>
<clix:chapter name='examples' title='Examples'>
<style type="text/css">
body { margin-left: 2em; }
p, blockquote { max-width: 45em; }
pre { margin-left: 3em; margin-right: 3em; word-wrap: break-word; overflow-x: auto; background: #eee; }
.arglist-spacer { margin-left: 6em; max-width: 45em; }
.repl-output { color: black; }
.repl-input { font-weight: bold; }
.headers-out { color: SteelBlue; }
.headers-in { color: SeaGreen; }
</style>
<p>
Here is a collection of example uses of Drakma to which
demonstrate some of its features. In the examples, text is
color coded to indicate where it comes from (<tt><span
class="repl-input">REPL input</span>, <span
class="repl-output">REPL output</span>, <span
class="headers-out">HTTP headers sent</span></tt> and <tt><span
class="headers-in">HTTP headers received</span></tt>). Headers
particularly relevant to the example at hand are shown <tt><span
class="headers-out"><b>in</b></span> <span
class="headers-in"><b>bold</b></span></tt>.
</p>
<clix:subchapter name='ex-loading' title='Loading Drakma with Quicklisp'>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :drakma)</span>
<span class="repl-output">To load "drakma":
Load 1 ASDF system:
drakma
; Loading "drakma"
To load "cl+ssl":
Load 1 ASDF system:
flexi-streams
Install 8 Quicklisp releases:
alexandria babel bordeaux-threads cffi cl+ssl
trivial-features trivial-garbage trivial-gray-streams
...
; Loading "drakma"
(:DRAKMA)
</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-logging' title='Log headers to the REPL output stream'>
<p>
In some of the following examples, the headers exchanged
between Drakma and the HTTP server should be shown, for
illustration purposes. This can be achieved like so:
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(setf drakma:*header-stream* *standard-output*)</span>
<span class="repl-output">#<SYNONYM-STREAM to *TERMINAL-IO* #x3020006AC7DD></span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-request-redirect' title='Requesting a page with redirection'>
<p>
Request a page. Note how Drakma automatically follows the 301
redirect and how the fourth return value shows the
<em>new</em> URI.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(<a href="#http-request">drakma:http-request</a> "http://lisp.org/")</span>
<span class="headers-out">GET / HTTP/1.1
Host: lisp.org
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 <b>307 Temporary Redirect</b>
Date: Sun, 09 Dec 2012 08:01:56 GMT
Connection: Close
Server: AllegroServe/1.2.65
Transfer-Encoding: chunked
<b>LOCATION: http://lisp.org/index.html</b>
</span>
<span class="headers-out"><b>GET /index.html HTTP/1.1</b>
Host: lisp.org
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:01:56 GMT
Connection: Close
Server: AllegroServe/1.2.65
Content-Type: text/html
Content-Length: 459
LAST-MODIFIED: Wed, 26 Oct 2011 02:26:26 GMT
</span>
<span class="repl-output">"<HTML>
<HEAD>
<title>John McCarthy, 1927-2011</title>
<STYLE type=\"text/css\">
BODY {text-align: center}
</STYLE>
</HEAD>
<BODY>
<h1>John McCarthy</h1>
<img src=\"jmccolor.jpg\" alt=\"a picture of John McCarthy, from his website\"/>
<h3>1927-2011</h3>
<br><br>
<a href=\"http://www-formal.stanford.edu/jmc/\">John McCarthy's Home Page</a><br>
<a href=\"http://news.stanford.edu/news/2011/october/john-mccarthy-obit-102511.html\">Obituary</a>
</BODY>
</HTML>
"
200
((:DATE . "Sun, 09 Dec 2012 08:01:56 GMT") (:CONNECTION . "Close") (:SERVER . "AllegroServe/1.2.65")
(:CONTENT-TYPE . "text/html") (:CONTENT-LENGTH . "459") (:LAST-MODIFIED . "Wed, 26 Oct 2011 02:26:26 GMT"))
#<URI http://lisp.org/index.html>
#<FLEXI-STREAMS:FLEXI-IO-STREAM #x30200155DB1D>
T
" OK"</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-charsets' title='Requesting a page containing non-ASCII characters'>
<p>
Drakma automatically interprets the 'charset=utf-8' part
correctly.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(subseq (<a href="#http-request">drakma:http-request</a> "http://www.cl.cam.ac.uk/~mgk25/ucs/examples/digraphs.txt") 0 298)</span>
<span class="headers-out">GET /~mgk25/ucs/examples/digraphs.txt HTTP/1.1
Host: www.cl.cam.ac.uk
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:15:04 GMT
Server: Apache/2.2.3 (CentOS)
Last-Modified: Mon, 06 Apr 2009 18:13:43 GMT
ETag: "17cd62-298-466e6dbcd03c0"
Accept-Ranges: bytes
Content-Length: 664
X-UA-Compatible: IE=edge
Connection: close
<b>Content-Type: text/plain; charset=utf-8</b>
</span>
<span class="repl-output">"Latin Digraphs and Ligatures in ISO10646-1
A short table of ligatures and digraphs follows. Some of these may not be
ligatures/digraphs in the technical sense, (for example, æ is a seperate
letter in English), but visually they behave that way.
AÆE : U+00C6
aæe : U+00E6
ſßs : U+00DF
IIJJ : U+0132"</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-binary-data' title='Requesting binary data'>
<p>
For non-textual content types, a vector of octets is returned.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(<a href="#http-request">drakma:http-request</a> "https://api.github.com/repos/edicl/drakma/git/tags/tag-does-not-exist")</span>
<span class="headers-out">GET /repos/edicl/drakma/git/tags/tag-does-not-exist HTTP/1.1
Host: api.github.com
User-Agent: Drakma/1.3.0 (SBCL 1.1.1.31.master.2-9fac43f-dirty; Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 404 Not Found
Server: nginx
Date: Fri, 28 Dec 2012 08:37:31 GMT
<b>Content-Type: application/json; charset=utf-8</b>
Connection: close
Status: 404 Not Found
X-GitHub-Media-Type: github.beta
X-RateLimit-Remaining: 48
X-RateLimit-Limit: 60
Content-Length: 23
X-Content-Type-Options: nosniff
Cache-Control:
</span>
<span class="repl-output">#(123 34 109 101 115 115 97 103 101 34 58 34 78 111 116 32 70 111 117 110 100 34 125)
404
((:SERVER . "nginx") (:DATE . "Fri, 28 Dec 2012 08:37:31 GMT") (:CONTENT-TYPE . "application/json; charset=utf-8")
(:CONNECTION . "close") (:STATUS . "404 Not Found") (:X-GITHUB-MEDIA-TYPE . "github.beta") (:X-RATELIMIT-REMAINING . "48")
(:X-RATELIMIT-LIMIT . "60") (:CONTENT-LENGTH . "23") (:X-CONTENT-TYPE-OPTIONS . "nosniff") (:CACHE-CONTROL . ""))
#<PURI:URI https://api.github.com/repos/edicl/drakma/git/tags/tag-does-not-exist>
#<FLEXI-STREAMS:FLEXI-IO-STREAM {101C40C043}>
T
"Not Found"</span>
<span class="repl-output">? </span><span class="repl-input">(<a href="http://weitz.de/flexi-streams/#octets-to-string" target="_new">flexi-streams:octets-to-string</a> *)</span>
<span class="repl-output">"{\"message\":\"Not Found\"}"</span></pre>
</clix:subchapter>
<clix:subchapter name='ex-chunked-https' title='Chunked transfers and HTTPS'>
<p>
Request a page using the HTTPS protocol. Also note that the
server uses <a name="chunked"
href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1">chunked
transfer encoding</a> for its reply
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :cl-ppcre)</span>
<span class="repl-output">? </span><span class="repl-input">(cl-ppcre:scan-to-strings "(?s)You have.*your data."
(<a href="#http-request">drakma:http-request</a> "https://www.fortify.net/cgi/ssl_2.pl"))</span>
<span class="headers-out">GET /cgi/ssl_2.pl HTTP/1.1
Host: www.fortify.net
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:15:31 GMT
Server: Apache
Connection: close
<b>Transfer-Encoding: chunked</b>
Content-Type: text/html
</span>
<span class="repl-output">"You have connected to this web server using the RC4-SHA encryption cipher
with a key length of 128 bits.
<p>
This is a high-grade encryption connection, regarded by most experts as being suitable
for sending or receiving even the most sensitive or valuable information
across a network.
<p>
In a crude analogy, using this cipher is similar to sending or storing your data inside
a high quality safe - compared to an export-grade cipher which is similar to using
a paper envelope to protect your data."
#()</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-fake-ua' title='Faking a user agent header'>
<p>
Some servers adapt their behavior according to the Browser
that is used. Drakma can claim to be i.e. MS Internet
Explorer.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(cl-ppcre:scan-to-strings "<h4>.*" (<a href="#http-request">drakma:http-request</a> "http://whatsmyuseragent.com/" <a href="#arg-user-agent">:user-agent :explorer</a>))</span>
<span class="headers-out">GET / HTTP/1.1
Host: whatsmyuseragent.com
<b>User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)</b>
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:23:50 GMT
Server: Apache
X-Powered-By: PHP/5.2.17
Connection: close
Transfer-Encoding: chunked
Content-Type: text/html
</span>
<span class="repl-output">"<h4>Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)</h4>"
#()</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-post-and-cookie' title='Posting data and using cookies'>
<p>
Drakma can send parameters in a POST request and knows how to
deal with <a href="#cookie">cookies</a>. Note how Drakma
sends the cookie back in the second request.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((cookie-jar (make-instance <a href="#cookie-jar">'drakma:cookie-jar</a>)))
(<a href="#http-request">drakma:http-request</a> "http://www.phpsecurepages.com/test/test.php"
<a href="#arg-method">:method :post</a>
<a href="#arg-parameters">:parameters '(("entered_login" . "test")
("entered_password" . "test"))</a>
<a href="#arg-cookie-jar">:cookie-jar cookie-jar</a>)
(<a href="#http-request">drakma:http-request</a> "http://www.phpsecurepages.com/test/test2.php"
<a href="#arg-cookie-jar">:cookie-jar cookie-jar</a>)
(<a href="#cookie-jar-cookies">drakma:cookie-jar-cookies</a> cookie-jar))</span>
<span class="headers-out">POST /test/test.php HTTP/1.1
Host: www.phpsecurepages.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 40
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:13 GMT
Server:
X-Powered-By: PHP/5.2.17
<b>Set-Cookie: PHPSESSID=vijk3706eojs7n8u5cdpi3ju05; path=/</b>
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
X-Powered-By: PleskLin
Content-Length: 4479
Connection: close
Content-Type: text/html
</span>
<span class="headers-out">GET /test/test2.php HTTP/1.1
Host: www.phpsecurepages.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
<b>Cookie: PHPSESSID=vijk3706eojs7n8u5cdpi3ju05</b>
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:16 GMT
Server:
X-Powered-By: PHP/5.2.17
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
X-Powered-By: PleskLin
Content-Length: 4479
Connection: close
Content-Type: text/html
</span>
<span class="repl-output">(#<COOKIE PHPSESSID=vijk3706eojs7n8u5cdpi3ju05; path=/; domain=www.phpsecurepages.com>)</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-reuse-connection' title='Reusing a connection to a server'>
<p>
Drakma can <a name="re-use">use</a> a connection to a server for multiple requests.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((stream (nth-value 4 (<a href="#http-request">drakma:http-request</a> "http://www.lispworks.com/" <a href="#arg-close">:close nil</a>))))
(nth-value 2 (<a href="#http-request">drakma:http-request</a> "http://www.lispworks.com/success-stories/index.html"
<a href="#arg-stream">:stream stream</a>)))</span>
<span class="headers-out">GET / HTTP/1.1
Host: www.lispworks.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:56 GMT
Server: Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9
Last-Modified: Tue, 20 Nov 2012 12:27:40 GMT
ETag: "336280-28eb-4ceec5c1f4700"
Accept-Ranges: bytes
Content-Length: 10475
Content-Type: text/html
</span>
<span class="headers-out">GET /success-stories/index.html HTTP/1.1
Host: www.lispworks.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
<b>Connection: close</b>
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:56 GMT
Server: Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9
Last-Modified: Tue, 20 Nov 2012 12:28:52 GMT
ETag: "336386-2940-4ceec6069e900"
Accept-Ranges: bytes
Content-Length: 10560
<b>Connection: close</b>
Content-Type: text/html
</span>
<span class="repl-output">((:DATE . "Sun, 09 Dec 2012 08:25:56 GMT")
(:SERVER . "Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9")
(:LAST-MODIFIED . "Tue, 20 Nov 2012 12:28:52 GMT") (:ETAG . "\"336386-2940-4ceec6069e900\"") (:ACCEPT-RANGES . "bytes")
(:CONTENT-LENGTH . "10560") (:CONNECTION . "close") (:CONTENT-TYPE . "text/html"))</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-basic-auth' title='Basic Authorization'>
<p>
Drakma supports basic authorization. In this example, we use
a locally running <a
href="http://weitz.de/hunchentoot">Hunchentoot</a> server.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :hunchentoot-test)</span>
<span class="repl-output">To load "hunchentoot-test":
Load 4 ASDF systems:
cl-ppcre cl-who drakma hunchentoot
Install 1 Quicklisp release:
hunchentoot
...
; Loading "hunchentoot-test"
(:HUNCHENTOOT-TEST)
? </span><span class="repl-input">(hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242))</span>
<span class="repl-output">#<EASY-ACCEPTOR (host *, port 4242)>
? </span><span class="repl-input">(nth-value 1 (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/authorization.html"))</span>
<span class="headers-out">GET /hunchentoot/test/authorization.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="repl-output">127.0.0.1 - [2012-12-09 09:27:40] "GET /hunchentoot/test/authorization.html HTTP/1.1" 401 543 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 <b>401 Authorization Required</b>
Content-Length: 543
Date: Sun, 09 Dec 2012 08:27:40 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Www-Authenticate: Basic realm="Hunchentoot"
Content-Type: text/html; charset=iso-8859-1
</span>
<span class="repl-output">401
? </span><span class="repl-input">(nth-value 1 (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/authorization.html"
<a href="#arg-basic-authorization">:basic-authorization '("nanook" "igloo")</a>))</span>
<span class="headers-out">GET /hunchentoot/test/authorization.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
<b>Authorization: Basic bmFub29rOmlnbG9v</b>
Accept: */*
Connection: close
</span>
<span class="repl-output">127.0.0.1 nanook [2012-12-09 09:28:15] "GET /hunchentoot/test/authorization.html HTTP/1.1" 200 907 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 200 OK
Content-Length: 907
Date: Sun, 09 Dec 2012 08:28:15 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Content-Type: text/html; charset=utf-8
</span>
<span class="repl-output">200</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-response-stream' title='Reading the response from a stream'>
<p>
Drakma can return a stream to the application so that the
reply is not completely buffered in memory first.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((stream (<a href="#http-request">drakma:http-request</a> "https://api.github.com/orgs/edicl/public_members"
<b>:want-stream t</b>)))
(setf (<a href="http://weitz.de/flexi-streams/#flexi-stream-external-format" target="_new">flexi-streams:flexi-stream-external-format</a> stream) :utf-8)
(<a href="http://common-lisp.net/project/yason/#parse" target="_new">yason:parse</a> stream :object-as :plist))</span>
<span class="headers-out">GET /orgs/edicl/public_members HTTP/1.1
Host: api.github.com
User-Agent: Drakma/1.3.0 (SBCL 1.1.1.31.master.2-9fac43f-dirty; Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Server: nginx
Date: Fri, 28 Dec 2012 10:27:34 GMT
Content-Type: application/json; charset=utf-8
Connection: close
Status: 200 OK
Last-Modified: Sat, 22 Dec 2012 18:39:14 GMT
X-Content-Type-Options: nosniff
X-RateLimit-Limit: 60
X-GitHub-Media-Type: github.beta
Vary: Accept
Content-Length: 1899
Cache-Control: public, max-age=60, s-maxage=60
ETag: "66a5dd35e79146a53029a1807293f9d3"
X-RateLimit-Remaining: 56
</span>
<span class="repl-output">(("type" "User" "repos_url" "https://api.github.com/users/hanshuebner/repos" "followers_url"
"https://api.github.com/users/hanshuebner/followers" "login" "hanshuebner" "gists_url"
"https://api.github.com/users/hanshuebner/gists{/gist_id}" "following_url"
"https://api.github.com/users/hanshuebner/following" "events_url"
"https://api.github.com/users/hanshuebner/events{/privacy}" "organizations_url"
"https://api.github.com/users/hanshuebner/orgs" "received_events_url"
"https://api.github.com/users/hanshuebner/received_events" "url"
"https://api.github.com/users/hanshuebner" "avatar_url"
"https://secure.gravatar.com/avatar/280d76aa82179ae04550534649de1e6e?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png"
"subscriptions_url" "https://api.github.com/users/hanshuebner/subscriptions" "starred_url"
"https://api.github.com/users/hanshuebner/starred{/owner}{/repo}" "id" 108751 "gravatar_id"
"280d76aa82179ae04550534649de1e6e")
("type" "User" "repos_url" "https://api.github.com/users/nhabedi/repos" "followers_url"
"https://api.github.com/users/nhabedi/followers" "login" "nhabedi" "gists_url"
"https://api.github.com/users/nhabedi/gists{/gist_id}" "following_url"
"https://api.github.com/users/nhabedi/following" "events_url"
"https://api.github.com/users/nhabedi/events{/privacy}" "organizations_url"
"https://api.github.com/users/nhabedi/orgs" "received_events_url"
"https://api.github.com/users/nhabedi/received_events" "url"
"https://api.github.com/users/nhabedi" "avatar_url"
"https://secure.gravatar.com/avatar/24c09c7b0b2c0481283d854bacdd7926?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png"
"subscriptions_url" "https://api.github.com/users/nhabedi/subscriptions" "starred_url"
"https://api.github.com/users/nhabedi/starred{/owner}{/repo}" "id" 537618 "gravatar_id"
"24c09c7b0b2c0481283d854bacdd7926"))</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-assemble-request-content' title='Piecemeal assembly of request contents'>
<p>
Request contents can be assembled from various sources, and
chunked encoding can be used by request bodies. Many servers
do not support chunked encoding for request bodies, though.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((temp-file (ensure-directories-exist #p"/tmp/quux.txt"))
(continuation (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/parameter_latin1_post.html"
<a href="#arg-method">:method :post</a>
<a href="#arg-content">:content :continuation</a>)))
(funcall continuation "foo=" t)
(funcall continuation (list (char-code #\z) (char-code #\a)) t)
(funcall continuation (lambda (stream)
(write-char #\p stream)) t)
(with-open-file (out temp-file
:direction :output
:if-does-not-exist :create
:if-exists :supersede)
(write-string "p" out))
(funcall continuation temp-file t)
(cl-ppcre:scan-to-strings "zappzerapp" (funcall continuation "zerapp")))</span>
<span class="headers-out">POST /hunchentoot/test/parameter_latin1_post.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
Content-Type: application/x-www-form-urlencoded
<b>Transfer-Encoding: chunked</b>
</span>
<span class="repl-output">127.0.0.1 - [2012-12-09 10:06:44] "POST /hunchentoot/test/parameter_latin1_post.html HTTP/1.1" 200 1312 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 200 OK
Content-Length: 1312
Date: Sun, 09 Dec 2012 09:06:44 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Last-Modified: Sun, 09 Dec 2012 09:06:44 GMT
Pragma: no-cache
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Expires: Mon, 26 Jul 1997 05:00:00 GMT
Content-Type: text/html; charset=ISO-8859-1
</span>
<span class="repl-output">"zappzerapp"
#()</span>
</pre>
</clix:subchapter>
<clix:subchapter name='ex-partial-transfers' title='Partial transfers'>
<p>
<a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35"
target="_new">Partial transfers</a> of resources are possible.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(cl-ppcre:regex-replace-all
"<.*?>"
(format nil "~A~%~A"
(<a href="#http-request">drakma:http-request</a> "http://members.shaw.ca/mitb/hunchentoot.html"
<a href="#arg-range">:range '(998 1034)</a>)
(<a href="#http-request">drakma:http-request</a> "http://members.shaw.ca/mitb/hunchentoot.html"
<a href="#arg-range">:range '(1213 1249)</a>))
"")</span>
<span class="headers-out">GET /mitb/hunchentoot.html HTTP/1.1
Host: members.shaw.ca
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
<b>Range: bytes=998-1034</b>
</span>
<span class="headers-in">HTTP/1.1 206 Partial Content
Date: Sun, 09 Dec 2012 09:16:16 GMT
Server: Apache/2.2.20 (Unix) mod_ldap_userdir/1.1.17
Last-Modified: Wed, 14 Mar 2012 23:22:04 GMT
ETag: "3b7eed-3238-4bb3c3e453f00"
Accept-Ranges: bytes
Content-Length: 37
<b>Content-Range: bytes 998-1034/12856</b>
Content-Type: text/html
Connection: close
</span>
<span class="headers-out">GET /mitb/hunchentoot.html HTTP/1.1
Host: members.shaw.ca
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
<b>Range: bytes=1213-1249</b>
</span>
<span class="headers-in">HTTP/1.1 206 Partial Content
Date: Sun, 09 Dec 2012 09:16:16 GMT
Server: Apache/2.2.20 (Unix) mod_ldap_userdir/1.1.17
Last-Modified: Wed, 14 Mar 2012 23:22:04 GMT
ETag: "3b7eed-3238-4bb3c3e453f00"
Accept-Ranges: bytes
Content-Length: 37
<b>Content-Range: bytes 1213-1249/12856</b>
Content-Type: text/html
</span>
<span class="repl-output">"DRAKMA (Queen of Cosmic Greed)
HUNCHENTOOT (The Giant Spider)"
T</span>
</pre>
</clix:subchapter>
</clix:chapter>
<clix:chapter name="install" title="Download and Installation">
<p>
Drakma depends on a number of open source libraries, so the
preferred method to download, compile and load it is via <a
href="http://www.quicklisp.org/">Quicklisp</a>. Drakma's
current version number is <clix:library-version/>.
</p>
<p>
The canonical location for the latest version of Drakma is <a
href="http://weitz.de/files/drakma.tar.gz">http://weitz.de/files/drakma.tar.gz</a>.
</p>
</clix:chapter>
<clix:chapter name="patches" title="Development and patches">
<p>
The development version of Drakma can be found <a
href="https://github.com/edicl/drakma" target="_new">on
github</a>. Please use the github issue tracking system to
submit bug reports. Patches are welcome, please use <a
href="https://github.com/edicl/drakma/pulls">GitHub pull
requests</a>. If you want to make a change, please <a
href="http://weitz.de/patches.html" target="_new">read this
first</a>.
</p>
</clix:chapter>
<clix:chapter name="dictionary" title="The Drakma dictionary">
<clix:subchapter name="dict-request" title="Requests">
<p>
The <clix:ref>HTTP-REQUEST</clix:ref> function is the heart of
Drakma. It is used to send requests to web servers and will
either return the message body of the server's reply or (if
the user so wishes) a stream one can read from. The wealth of
keyword parameters might look a bit intimidating first, but
you will rarely need more than two or three of them - the
default behavior of Drakma is (hopefully) designed to do The
Right Thing[TM] in most cases.
</p>
<p>
You can use the <clix:ref>*HEADER-STREAM*</clix:ref> variable
to debug requests handled by Drakma in a way similar to <a
href="http://livehttpheaders.mozdev.org/">LiveHTTPHeaders</a>.
</p>
<clix:function name="http-request">
<clix:special-definition>
[Function]<br/>
<b>http-request</b> <i>uri</i><div class="arglist-spacer">&rest args</div>
<div class="arglist-spacer">&key
<a href="#arg-protocol">protocol</a>
<a href="#arg-method">method</a>
<a href="#arg-force-ssl">force-ssl</a>
<a href="#arg-certificate">certificate</a>
<a href="#arg-key">key</a>
<a href="#arg-certificate-password">certificate-password</a>
<a href="#arg-verify">verify</a>
<a href="#arg-max-depth">max-depth</a>
<a href="#arg-ca-file">ca-file</a>
<a href="#arg-ca-directory">ca-directory</a>
<a href="#arg-parameters">parameters</a>
<a href="#arg-url-encoder">url-encoder</a>
<a href="#arg-content">content</a>
<a href="#arg-content-type">content-type</a>
<a href="#arg-content-length">content-length</a>
<a href="#arg-form-data">form-data</a>
<a href="#arg-cookie-jar">cookie-jar</a>
<a href="#arg-basic-authorization">basic-authorization</a>
<a href="#arg-user-agent">user-agent</a>
<a href="#arg-accept">accept</a>
<a href="#arg-range">range</a>
<a href="#arg-proxy">proxy</a>
<a href="#arg-proxy-basic-authorization">proxy-basic-authorization</a>
<a href="#arg-real-host">real-host</a>
<a href="#arg-additional-headers">additional-headers</a>
<a href="#arg-redirect">redirect</a>
<a href="#arg-auto-referer">auto-referer</a>
<a href="#arg-keep-alive">keep-alive</a>
<a href="#arg-close">close</a>
<a href="#arg-external-format-out">external-format-out</a>
<a href="#arg-external-format-in">external-format-in</a>
<a href="#arg-force-binary">force-binary</a>
<a href="#arg-want-stream">want-stream</a>
<a href="#arg-stream">stream</a>
<a href="#arg-preserve-uri">preserve-uri</a>
<a href="#arg-connection-timeout">connection-timeout</a>
<a href="#arg-deadline">deadline</a>
</div>
<div class="arglist-spacer">
=> body-or-stream<sup>0</sup>, status-code<sup>1</sup>,
headers<sup>2</sup>, uri<sup>3</sup>, stream<sup>4</sup>,
<a href="#arg-want-stream">must-close<sup>5</sup></a>,
reason-phrase<sup>6</sup>
</div>
</clix:special-definition>
<clix:description>
<p>
Sends an <a
href="http://www.w3.org/Protocols/rfc2616/rfc2616.html">HTTP</a>
request to a web server and returns its reply.
<clix:arg>uri</clix:arg> is where the request is sent to,
and it is either a string denoting a uniform resource
identifier or a <code>PURI:URI</code> object. The scheme
of <clix:arg>uri</clix:arg> must be `http' or `https'.
The function returns SEVEN values - the body of the
reply<sup>0</sup> (but see below), the status
code<sup>1</sup> as an integer, an alist of the
headers<sup>2</sup> sent by the server where for each
element the car (the name of the header) is a keyword and
the cdr (the value of the header) is a string, the
uri<sup>3</sup> the reply comes from (which might be
different from the <clix:arg>uri</clix:arg> the request
was sent to in case of redirects), the stream<sup>4</sup>
the reply was read from, a generalized boolean<sup>5</sup>
which denotes whether the stream should be closed (and
which you can usually ignore), and finally the reason
phrase<sup>6</sup> from the status line as a string.
</p>
<p>
<a name="arg-protocol"/>
<clix:arg>protocol</clix:arg> is the HTTP protocol version
which is going to be used in the request line. It must be
one of the keywords <code>:HTTP/1.0</code> or
<code>:HTTP/1.1</code>.
</p>
<p>
<a name="arg-method"/>
<clix:arg>method</clix:arg> is the method used in the
request line, a keyword (like <code>:GET</code> or
<code>:HEAD</code>) denoting a valid HTTP/1.1 or WebDAV
request method, or <code>:REPORT</code>, as described in
the Versioning Extensions to WebDAV. Additionally, you
can also use the pseudo method <code>:OPTIONS*</code>
which is like <code>:OPTIONS</code> but means that an
"OPTIONS *" request line will be sent, i.e. the
<clix:arg>uri</clix:arg>'s path and query parts will be
ignored.
</p>
<p><a name="arg-force-ssl"/>
If <clix:arg>force-ssl</clix:arg> is true, SSL will be
attached to the socket stream which connects Drakma with
the web server. Usually, you don't have to provide this
argument, as SSL will be attached anyway if the scheme of
<clix:arg>uri</clix:arg> is `https'.
</p>
<p><a name="arg-certificate"/><a
name="arg-certificate-password"/><a name="arg-key"/>
<clix:arg>certificate</clix:arg> is the file name of the PEM
encoded client certificate to present to the server when
making a SSL connection. <clix:arg>key</clix:arg> specifies
the file name of the PEM encoded private key matching the
certificate. <clix:arg>certificate-password</clix:arg>
specifies the pass phrase to use to decrypt the private key.
</p>
<p>
<a name="arg-verify"/>
<clix:arg>verify</clix:arg> can be specified to force
verification of the certificate that is presented by the
server in an SSL connection. It can be specified either
as <code>NIL</code> if no check should be performed,
<code>:OPTIONAL</code> to verify the server's certificate
if it presented one or <code>:REQUIRED</code> to verify
the server's certificate and fail if an invalid or no
certificate was presented.
</p>
<p>
<a name="arg-max-depth"/>
<clix:arg>max-depth</clix:arg> can be specified to change
the maximum allowed certificate signing depth that is
accepted. The default is 10.
</p>
<p>
<a name="arg-ca-file"/>
<a name="arg-ca-directory"/>
<clix:arg>ca-file</clix:arg> and
<clix:arg>ca-directory</clix:arg> can be specified to set
the certificate authority bundle file or directory to use
for certificate validation.
</p>
<p>
The <clix:arg>certificate</clix:arg>,
<clix:arg>key</clix:arg>,
<clix:arg>certificate-password</clix:arg>,
<clix:arg>verify</clix:arg>,
<clix:arg>max-depth</clix:arg>,
<clix:arg>ca-file</clix:arg> and
<clix:arg>ca-directory</clix:arg> parameters are ignored
for non-SSL requests. They are also ignored on LispWorks.
</p>
<p>
<a name="arg-parameters"/>
<a name="arg-form-data"/>
<clix:arg>parameters</clix:arg> is an alist of name/value
pairs (the car and the cdr each being a string) which
denotes the parameters which are added to the query part
of the URL or (in the case of a POST request) comprise the
body of the request. (But see
<clix:arg>content</clix:arg> below.) The values can also
be <code>NIL</code> in which case only the name (without
an equal sign) is used in the query string. The
name/value pairs are URL-encoded using the FLEXI-STREAMS
external format <clix:arg>external-format-out</clix:arg>
before they are sent to the server unless
<clix:arg>form-data</clix:arg> is true in which case the
POST request body is sent as `multipart/form-data' using
<clix:arg>external-format-out</clix:arg>. The values of
the <clix:arg>parameters</clix:arg> alist can also be
pathnames, open binary input streams, unary functions, or
lists where the first element is of one of the former
types. These values denote files which should be sent as
part of the request body. If files are present in
<clix:arg>parameters</clix:arg>, the content type of the
request is always `multipart/form-data'. If the value is
a list, the part of the list behind the first element is
treated as a plist which can be used to specify a content
type and/or a filename for the file, i.e. such a value
could look like, e.g., <tt>(#p"/tmp/my_file.doc"
:content-type "application/msword" :filename
"upload.doc")</tt>.
</p>
<p>
<a name="arg-url-encoder"/>
<clix:arg>url-encoder</clix:arg> specifies a custom URL
encoder function which will be used by drakma to
URL-encode parameter names and values. It needs to be a
function of two arguments. The arguments are the string
to encode and the external format to use (as accepted by
FLEXI-STREAMS:STRING-TO-OCTETS). The return value must be
the URL-encoded string. This can be used if specific
encoding rules are required.
</p>
<p>
<a name="arg-content"/>
<a name="arg-external-format-out"/>
<clix:arg>content</clix:arg>, if not <code>NIL</code>, is
used as the request body - <clix:arg>parameters</clix:arg>
is ignored in this case. <clix:arg>content</clix:arg> can
be a string, a sequence of octets, a pathname, an open
binary input stream, or a function designator. If
<clix:arg>content</clix:arg> is a sequence, it will be
directly sent to the server (using
<clix:arg>external-format-out</clix:arg> in the case of
strings). If <clix:arg>content</clix:arg> is a pathname,
the binary contents of the corresponding file will be sent
to the server. If <clix:arg>content</clix:arg> is a
stream, everything that can be read from the stream until
EOF will be sent to the server. If
<clix:arg>content</clix:arg> is a function designator, the
corresponding function will be called with one argument,
the stream to the server, to which it should send data.
</p>
<p>
Finally, <clix:arg>content</clix:arg> can also be the
keyword <code>:CONTINUATION</code> in which case
<clix:ref>HTTP-REQUEST</clix:ref> returns only one value -
a `continuation' function. This function has one required
argument and one optional argument. The first argument
will be interpreted like <clix:arg>content</clix:arg>
above (but it cannot be a keyword), i.e. it will be sent
to the server according to its type. If the second
argument is true, the continuation function can be called
again to send more content, if it is <code>NIL</code> the
continuation function returns what
<clix:ref>HTTP-REQUEST</clix:ref> would have returned.
</p>
<p>
If <clix:arg>content</clix:arg> is a sequence, Drakma will
use LENGTH to determine its length and will use the result
for the `Content-Length' header sent to the server. You
can overwrite this with the
<clix:arg>content-length</clix:arg> parameter (a
non-negative integer) which you can also use for the cases
where Drakma can't or won't determine the content length
itself. You can also explicitly provide a
<clix:arg>content-length</clix:arg> argument of
<code>NIL</code> which will imply that no `Content-Length'
header will be sent in any case. If no `Content-Length'
header is sent, Drakma will use chunked encoding to send
the content body. Note that this will not work with older
web servers.
</p>
<p>
<a name="arg-content-length"/>
Providing a true <clix:arg>content-length</clix:arg>
argument which is not a non-negative integer means that
Drakma /must/ build the request body in RAM and compute
the content length even if it would have otherwise used
chunked encoding, for example in the case of file uploads.
</p>
<p>
<a name="arg-content-type"/>
<clix:arg>content-type</clix:arg> is the corresponding
`Content-Type' header to be sent and will be ignored
unless <clix:arg>content</clix:arg> is provided as well.
</p>
<p>
Note that a query already contained in
<clix:arg>uri</clix:arg> will always be sent with the
request line anyway in addition to other parameters sent
by Drakma.
</p>
<p>
<a name="arg-cookie-jar"/>
<clix:arg>cookie-jar</clix:arg> is a cookie jar containing
cookies which will potentially be sent to the server (if
the domain matches, if they haven't expired, etc.) - this
cookie jar will be modified according to the `Set-Cookie'
header(s) sent back by the server.
</p>
<p>
<a name="arg-basic-authorization"/>
<clix:arg>basic-authorization</clix:arg>, if not
<code>NIL</code>, should be a list of two strings
(username and password) which will be sent to the server
for basic authorization.
</p>
<p>
<a name="arg-user-agent"/>
<clix:arg>user-agent</clix:arg>, if not <code>NIL</code>,
denotes which `User-Agent' header will be sent with the
request. It can be one of the keywords
<code>:DRAKMA</code>, <code>:FIREFOX</code>,
<code>:EXPLORER</code>, <code>:OPERA</code>, or
<code>:SAFARI</code> which denote the current version of
Drakma or, in the latter four cases, a fixed string
corresponding to a more or less recent (as of August 2006)
version of the corresponding browser. Or it can be a
string which is used directly.
</p>
<p>
<a name="arg-accept"/>
<clix:arg>accept</clix:arg>, if not <code>NIL</code>,
specifies the contents of the `Accept' header sent.
</p>
<p>
<a name="arg-range"/>
<clix:arg>range</clix:arg> optionally specifies a subrange
of the resource to be requested. It must be specified as
a list of two integers which indicate the start and
(inclusive) end offset of the requested range, in bytes
(i.e. octets).
</p>
<p>
<a name="arg-proxy"/>
<a name="arg-proxy-basic-authorization"/>
If <clix:arg>proxy</clix:arg> is not <code>NIL</code>, it
should be a string denoting a proxy server through which
the request should be sent. Or it can be a list of two
values - a string denoting the proxy server and an integer
denoting the port to use (which will default to 80
otherwise). Defaults to
<clix:arg>*default-http-proxy*</clix:arg>.
<clix:arg>proxy-basic-authorization</clix:arg> is used
like <clix:arg>basic-authorization</clix:arg>, but for the
proxy, and only if <clix:arg>proxy</clix:arg> is true. If
the host portion of the uri is present in the
<clix:ref>*NO-PROXY-DOMAINS*</clix:ref> or the
<clix:arg>NO-PROXY-DOMAINS</clix:arg> list then the proxy
setting will be ignored for this request.
</p>
<p>
If <clix:arg>NO-PROXY-DOMAINS</clix:arg> is set then it
will supersede the <clix:ref>*NO-PROXY-DOMAINS*</clix:ref>
variable. Inserting domains into this list will allow them
to ignore the proxy setting.
</p>
<p>
<a name="arg-real-host"/>
If <clix:arg>real-host</clix:arg> is not <code>NIL</code>,
request is sent to the denoted host instead of the
<clix:arg>uri</clix:arg> host. When specified,
<clix:arg>real-host</clix:arg> supersedes
<clix:arg>proxy</clix:arg>.
</p>
<p>
<a name="arg-additional-headers"/>
<clix:arg>additional-headers</clix:arg> is a name/value
alist of additional HTTP headers which should be sent with
the request. Unlike in <clix:arg>parameters</clix:arg>,
the cdrs can not only be strings but also designators for
unary functions (which should in turn return a string) in
which case the function is called each time the header is
written.
</p>
<p>
<a name="arg-redirect"/>
<a name="arg-auto-referer"/>
If <clix:arg>redirect</clix:arg> is not <code>NIL</code>,
it must be a non-negative integer or T. If
<clix:arg>redirect</clix:arg> is true, Drakma will follow
redirects (return codes 301, 302, 303, or 307) unless
<clix:arg>redirect</clix:arg> is 0. If
<clix:arg>redirect</clix:arg> is an integer, it will be
decreased by 1 with each redirect. Furthermore, if
<clix:arg>auto-referer</clix:arg> is true when following
redirects, Drakma will populate the `Referer' header with
the <clix:arg>uri</clix:arg> that triggered the
redirection, overwriting an existing `Referer' header (in
<clix:arg>additional-headers</clix:arg>) if necessary.
</p>
<p>
<a name="arg-keep-alive"/>
<a name="arg-close"/>
If <clix:arg>keep-alive</clix:arg> is T, the server will
be asked to keep the connection alive, i.e. not to close
it after the reply has been sent. (Note that this not
necessary if both the client and the server use HTTP 1.1.)
If <clix:arg>close</clix:arg> is T, the server is
explicitly asked to close the connection after the reply
has been sent. <clix:arg>keep-alive</clix:arg> and
<clix:arg>close</clix:arg> are obviously mutually
exclusive.
</p>
<p>
<a name="arg-external-format-in"/>
<a name="arg-force-binary"/>
If the message body sent by the server has a text content
type, Drakma will try to return it as a Lisp string.
It'll first check if the `Content-Type' header denotes an
encoding to be used, or otherwise it will use the
<clix:arg>external-format-in</clix:arg> argument. The
body is decoded using FLEXI-STREAMS. If FLEXI-STREAMS
doesn't know the external format, the body is returned as
an array of octets. If the body is empty, Drakma will
return <code>NIL</code>.
</p>
<p>
If the message body doesn't have a text content type or if
<clix:arg>force-binary</clix:arg> is true, the body is
always returned as an array of octets.
</p>
<p>
<a name="arg-want-stream"/>
If <clix:arg>want-stream</clix:arg> is true, the message
body is NOT read and instead the (open) socket stream is
returned as the first return value. If the sixth value of
<clix:ref>HTTP-REQUEST</clix:ref> is true, the stream
should be closed (and not be re-used) after the body has
been read. The stream returned is a <a
href="http://weitz.de/flexi-streams/">flexi-stream</a>
with a <a href="http://weitz.de/chunga/"
target="_new">chunked stream</a> as its underlying stream.
If you want to read binary data from this stream, read
from the underlying stream which you can get with
FLEXI-STREAM-STREAM.
</p>
<p>
<a name="arg-stream"/>
Drakma will usually create a new socket connection for
each HTTP request. However, you can use the
<clix:arg>stream</clix:arg> argument to provide an open
socket stream which should be re-used.
<clix:arg>stream</clix:arg> MUST be a stream returned by a
previous invocation of <clix:ref>HTTP-REQUEST</clix:ref>
where the sixth return value wasn't true. Obviously, it
must also be connected to the correct server and at the
right position (i.e. the message body, if any, must have
been read). Drakma will NEVER attach SSL to a stream
provided as the <clix:arg>stream</clix:arg> argument.
</p>
<p>
<a name="arg-connection-timeout"/>
<clix:arg>connection-timeout</clix:arg> is the time (in
seconds) Drakma will wait until it considers an attempt to
connect to a server as a failure. It is supported only on
some platforms (currently abcl, clisp, LispWorks, mcl,
openmcl and sbcl). READ-TIMEOUT and WRITE-TIMEOUT are the
read and write timeouts (in seconds) for the socket stream
to the server. All three timeout arguments can also be
<code>NIL</code> (meaning no timeout), and they don't
apply if an existing stream is re-used. READ-TIMEOUT
argument is only available for LispWorks, WRITE-TIMEOUT is
only available for LispWorks 5.0 or higher.
</p>
<p>
<a name="arg-deadline"/>
<clix:arg>deadline</clix:arg>, a time in the future,
specifies the time until which the request should be
finished. The deadline is specified in internal time
units. If the server fails to respond until that time, a
COMMUNICATION-DEADLINE-EXPIRED condition is signalled.
<clix:arg>deadline</clix:arg> is only available on CCL 1.2
and later.
</p>
<p>
<a name="arg-preserve-uri"/>
If <clix:arg>preserve-uri</clix:arg> is not
<code>NIL</code>, the given <clix:arg>uri</clix:arg> will
not be processed. This means that the
<clix:arg>uri</clix:arg> will be sent as-is to the remote
server and it is the responsibility of the client to make
sure that all parameters are encoded properly. Note that
if this parameter is given, and the request is not a POST
with a content-type of `multipart/form-data',
<clix:arg>parameters</clix:arg> will not be used.
</p>
<p>
If <clix:arg>decode-content</clix:arg> is not
<code>NIL</code>, then the content will automatically be
decoded according to any encodings specified in the
Content-Encoding header. The actual decoding is done by
the <clix:ref>decode-stream</clix:ref> generic function,
and you can implement new methods to support additional
encodings. Any encodings in Transfer-Encoding, such as
chunking, are always performed.
</p>
</clix:description>
</clix:function>
<clix:function name="parameter-present-p">
<clix:lambda-list>name parameters</clix:lambda-list>
<clix:returns>boolean</clix:returns>
<clix:description>
<p>
If <clix:arg>parameters</clix:arg> is an alist of
parameters as returned by, for example,
READ-TOKENS-AND-PARAMETERS and <clix:arg>name</clix:arg>
is a string naming a parameter, this function returns the
full parameter (name and value) - or <code>NIL</code> if
it's not in <clix:arg>parameters</clix:arg>.
</p>
</clix:description>
</clix:function>
<clix:function name="parameter-value">
<clix:lambda-list>name parameters</clix:lambda-list>
<clix:returns>(or string null)</clix:returns>
<clix:description>
<p>
If <clix:arg>parameters</clix:arg> is an alist of
parameters as returned by, for example,
READ-TOKENS-AND-PARAMETERS and <clix:arg>name</clix:arg>
is a string naming a parameter, this function returns the
value of this parameter - or <code>NIL</code> if it's not
in <clix:arg>parameters</clix:arg>.
</p>
</clix:description>
</clix:function>
<clix:function name="url-encode">
<clix:lambda-list>string external-format</clix:lambda-list>
<clix:returns>string</clix:returns>
<clix:description>
<p>
Returns a URL-encoded version of the string
<clix:arg>string</clix:arg> using the external format
<clix:arg>external-format</clix:arg>.
</p>
</clix:description>
</clix:function>
<clix:function name="decode-stream">
<clix:lambda-list>encoding-type stream</clix:lambda-list>
<clix:returns>stream</clix:returns>
<clix:description>
<p>
Generic function to decode a stream. This is a generic
function which decodes the stream based on the
encoding-type. If a response contains one or more
transfer or content encodings, then decode-stream is
called for each encoding type in the correct order to
properly decode the stream to its original content.
</p>
<p>
<clix:arg>encoding-type</clix:arg> will be a keyword
created by upcasing and interning the encoding type from
the header. <clix:arg>stream</clix:arg> will be the
stream that needs to be
decoded. <clix:ref>decode-stream</clix:ref> returns a new
stream from which you can read the decoded data.
</p>
</clix:description>
</clix:function>
<clix:special-variable name="*body-format-function*">
<clix:description>
<p>
A function which determines whether the content body
returned by the server is text and should be treated as
such or not. The function is called after the request
<clix:ref>headers</clix:ref> have been read and it must
accept two arguments, <code><i>headers</i></code> and
<code><i>external-format-in</i></code>, where
<code><i>headers</i></code> is like the third return value
of <clix:ref>HTTP-REQUEST</clix:ref> while
<code><i>external-format-in</i></code> is the
<clix:ref>HTTP-REQUEST</clix:ref> argument of the same
name. It should return <code>NIL</code> if the body
should be regarded as binary content, or a <a
href="http://weitz.de/flexi-streams/">FLEXI-STREAMS</a>
external format (which will be used to read the body)
otherwise.
</p>
<p>
This function will only be called if the <a
href="#arg-force-binary"><code><i>force-binary</i></code></a>
argument to <clix:ref>HTTP-REQUEST</clix:ref> is
<code>NIL</code>.
</p>
<p>
The initial value of this variable is a function which
uses <clix:ref>*TEXT-CONTENT-TYPES*</clix:ref> to
determine whether the body is text and then proceeds as
described in the <clix:ref>HTTP-REQUEST</clix:ref>
documentation entry.
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*default-http-proxy*">
<clix:description>
<p>
HTTP proxy to be used as default for the proxy keyword
argument of <clix:ref>HTTP-REQUEST</clix:ref>. If not
<code>NIL</code>, it should be a string denoting a proxy
server through which the request should be sent. Or it
can be a list of two values - a string denoting the proxy
server and an integer denoting the port to use (which
will default to 80 otherwise).
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*no-proxy-domains*">
<clix:description>
<p>
A list of domains for which a proxy should not be used.
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*drakma-default-external-format*">
<clix:description>
<p>
The default value for the external format keyword
arguments of <clix:ref>HTTP-REQUEST</clix:ref>. The value
of this variable will be interpreted by <a
href="http://weitz.de/flexi-streams/">FLEXI-STREAMS</a>.
The initial value is the keyword <code>:LATIN-1</code>.
(Note that Drakma binds <a
href="http://weitz.de/flexi-streams/#*default-eol-style*"><code>*DEFAULT-EOL-STYLE*</code></a>
to <code>:LF</code>).
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*header-stream*">
<clix:description>
<p>
If this variable is not <code>NIL</code>, it should be
bound to a stream to which incoming and outgoing headers
will be written for debugging purposes.
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*text-content-types*">
<clix:description>
<p>
A list of conses which are used by the default value of
<clix:ref>*BODY-FORMAT-FUNCTION*</clix:ref> to decide
whether a 'Content-Type' header denotes text content. The
car and cdr of each cons should each be a string or
<code>NIL</code>. A content type matches one of these
entries (and thus denotes text) if the type part is <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/f_stgeq_.htm"><code>STRING-EQUAL</code></a>
to the car or if the car is <code>NIL</code> and if the
subtype part is <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/f_stgeq_.htm"><code>STRING-EQUAL</code></a>
to the cdr or if the cdr is <code>NIL</code>.
</p>
<p>
The initial value of this variable is the list
<pre>(("text" . nil))</pre> which means that every content
type that starts with "text/" is regarded as text, no
matter what the subtype is.
</p>
</clix:description>
</clix:special-variable>
</clix:subchapter>
<clix:subchapter name="headers" title="Headers">
<p>
This section assembles a couple of convenience functions which
can be used to access information returned as the third value
(<code><i>headers</i></code>) of
<clix:ref>HTTP-REQUEST</clix:ref>.
</p>
<p>
Note that if the server sends <a
href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2">multiple
headers with the same name</a>, these are comprised into one
entry by <clix:ref>HTTP-REQUEST</clix:ref>. The values are
separated by commas.
</p>
<clix:function name="get-content-type">
<clix:lambda-list>headers</clix:lambda-list>
<clix:returns>list</clix:returns>
<clix:description>
<p>
Reads and parses a `Content-Type' header and returns it as
three values - the type, the subtype, and an alist
(possibly empty) of name/value pairs for the optional
parameters. <clix:arg>headers</clix:arg> is supposed to
be an alist of headers as returned by
<clix:ref>HTTP-REQUEST</clix:ref>. Returns
<code>NIL</code> if there is no such header amongst
<clix:arg>headers</clix:arg>.
</p>
</clix:description>
</clix:function>
<clix:function name="header-value">
<clix:lambda-list>name headers</clix:lambda-list>
<clix:returns>(or string null)</clix:returns>
<clix:description>
<p>
If <clix:arg>headers</clix:arg> is an alist of headers as
returned by <clix:ref>HTTP-REQUEST</clix:ref> and
<clix:arg>name</clix:arg> is a keyword naming a header,
this function returns the corresponding value of this
header (or <code>NIL</code> if it's not in
<clix:arg>headers</clix:arg>).
</p>
</clix:description>
</clix:function>
<clix:function name="read-tokens-and-parameters">
<clix:lambda-list>string &key value-required-p</clix:lambda-list>
<clix:returns>list</clix:returns>
<clix:description>
<p>
Reads a comma-separated list of tokens from the string
<clix:arg>string</clix:arg>. Each token can be followed
by an optional, semicolon-separated list of
attribute/value pairs where the attributes are tokens
followed by a #\= character and a token or a quoted
string. Returned is a list where each element is either a
string (for a simple token) or a cons of a string (the
token) and an alist (the attribute/value pairs). If
<clix:arg>value-required-p</clix:arg> is <code>NIL</code>,
the value part (including the #\= character) of each
attribute/value pair is optional.
</p>
</clix:description>
</clix:function>
<clix:function name="split-tokens">
<clix:lambda-list>string</clix:lambda-list>
<clix:returns>list</clix:returns>
<clix:description>
<p>
Splits the string <clix:arg>string</clix:arg> into a list
of substrings separated by commas and optional whitespace.
Empty substrings are ignored.
</p>
</clix:description>
</clix:function>
</clix:subchapter>
<clix:subchapter name="cookies" title="Cookies">
<p>
<clix:ref>HTTP-REQUEST</clix:ref> can deal with <a
href="http://en.wikipedia.org/wiki/HTTP_cookie">HTTP
cookies</a> if it gets a <a href="#cookie-jar">cookie jar</a>,
a collection of <clix:ref>COOKIE</clix:ref> objects, as its <a
href="#arg-cookie-jar">cookie-jar</a> argument. Cookies sent
by the web server will be added to the cookie jar (or updated)
if appropriate and cookies already in the cookie jar will be
sent to the server together with the request.
</p>
<p>
Drakma will never remove cookies from a cookie jar
automatically. You have to do it manually using
<clix:ref>DELETE-OLD-COOKIES</clix:ref>.
</p>
<clix:class name="cookie">
<clix:description>
<p>
Instances of this class represent <a
href="http://en.wikipedia.org/wiki/HTTP_cookie">HTTP
cookies</a>. If you need to create your own cookies, you
should use <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/f_mk_ins.htm"><code>MAKE-INSTANCE</code></a>
with the initargs <code>:NAME</code>, <code>:DOMAIN</code>,
<code>:VALUE</code>, <code>:PATH</code>,
<code>:EXPIRES</code>, <code>:SECUREP</code>, and
<code>:HTTP-ONLY-P</code> all of which are optional except
for the first two. The meaning of these initargs and <a
href="#cookie-name">the corresponding accessors</a> should
be pretty clear if one looks at the <a
href="http://curl.haxx.se/rfc/cookie_spec.html">original
cookie specification</a> (and at <a
href="http://msdn2.microsoft.com/en-us/library/ms533046.aspx">this
page</a> for the <code>HttpOnly</code> extension).
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(make-instance 'drakma:cookie
:name "Foo"
:value "Bar"
:expires (+ (get-universal-time) 3600)
:domain ".weitz.de")</span>
<span class="repl-output">#<COOKIE Foo=Bar; expires=Sun, 09-12-2012 20:37:42 GMT; path=/; domain=.weitz.de></span>
</pre>
</clix:description>
</clix:class>
<clix:function name="parse-cookie-date">
<clix:lambda-list>string</clix:lambda-list>
<clix:returns>universal-time</clix:returns>
<clix:description>
<p>
Parses a cookie expiry date and returns it as a Lisp <a
href="http://www.lispworks.com/documentation/HyperSpec/Body/25_adb.htm">universal
time</a>. Currently understands the following formats:
</p>
<pre>"Wed, 06-Feb-2008 21:01:38 GMT"
"Wed, 06-Feb-08 21:01:38 GMT"
"Tue Feb 13 08:00:00 2007 GMT"
"Wednesday, 07-February-2027 08:55:23 GMT"
"Wed, 07-02-2017 10:34:45 GMT"</pre>
<p>
Instead of "GMT" time zone abbreviations like "CEST" and UTC
offsets like "GMT-01:30" are also allowed.
</p>
<p>
While this function has "cookie" in its name, it might
come in handy in other situations as well and it is thus
exported as a convenience function.
</p>
</clix:description>
</clix:function>
<clix:function name="cookie=">
<clix:lambda-list>cookie1 cookie2</clix:lambda-list>
<clix:returns>boolean</clix:returns>
<clix:description>
Returns a true value if the cookies
<clix:arg>cookie1</clix:arg> and
<clix:arg>cookie2</clix:arg> are equal. Two cookies are
considered to be equal if name and path are equal.
</clix:description>
</clix:function>
<clix:accessors generic='true'>
<clix:listed-accessor generic='true' name='cookie-name'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>string</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-value'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>(or string null)</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-domain'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>string</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-path'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>(or string null)</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-expires'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>(or integer null)</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-http-only-p'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>boolean</clix:returns>
</clix:listed-accessor>
<clix:listed-accessor generic='true' name='cookie-securep'>
<clix:lambda-list>cookie</clix:lambda-list>
<clix:returns>boolean</clix:returns>
</clix:listed-accessor>
</clix:accessors>
<clix:class name="cookie-jar">
<clix:description>
<p>
An object of this class encapsulates a collection (a list,
actually) of <code>COOKIE</code> objects. You create a new
cookie jar with <code>(MAKE-INSTANCE 'COOKIE-JAR)</code>
where you can optionally provide a list of
<clix:ref>COOKIE</clix:ref> objects with the
<code>:COOKIES</code> initarg. The cookies in a cookie jar
are accessed with <clix:ref>COOKIE-JAR-COOKIES</clix:ref>.
</p>
</clix:description>
</clix:class>
<clix:accessors generic='true'>
<clix:listed-accessor generic='true' name='cookie-jar-cookies'>
<clix:lambda-list>cookie-jar</clix:lambda-list>
<clix:returns>list</clix:returns>
</clix:listed-accessor>
</clix:accessors>
<clix:function name="delete-old-cookies">
<clix:lambda-list>cookie-jar</clix:lambda-list>
<clix:returns>cookie-jar</clix:returns>
<clix:description>
<p>
Removes all cookies from <clix:arg>cookie-jar</clix:arg>
which have either expired or which don't have an expiry
date.
</p>
</clix:description>
</clix:function>
<clix:special-variable name="*allow-dotless-cookie-domains-p*">
<clix:description>
<p>
When this variable is not <code>NIL</code>, cookie domains
containing no dots are considered valid. The default is
<code>NIL</code>, meaning to disallow such domains except
for "localhost".
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*ignore-unparseable-cookie-dates-p*">
<clix:description>
<p>
Whether Drakma is allowed to treat `Expires' dates in
cookie headers as non-existent if it can't parse them. If
the value of this variable is <code>NIL</code> (which is
the default), an error will be signalled instead.
</p>
</clix:description>
</clix:special-variable>
<clix:special-variable name="*remove-duplicate-cookies-p*">
<clix:description>
<p>
Determines how duplicate cookies in the response are
handled, defaults to <code>T</code>. Cookies are
considered duplicate using <a
href="#cookie="><code>COOKIE=</code></a>.
</p>
<p>
Valid values are:
<ul>
<li><code>NIL</code> - duplicates will not be
removed,</li>
<li><code>T</code> or <code>:KEEP-LAST</code> - for
duplicates, only the last cookie value will be kept,
based on the order of the response header,</li>
<li><code>:KEEP-FIRST</code> - for duplicates, only the
first cookie value will be kept, based on the order of
the response header.</li>
</ul>
</p>
<p>
Misbehaving servers may send duplicate cookies back in the
same <code>Set-Cookie</code> header:
</p>
<pre>HTTP/1.1 200 OK
Server: My-hand-rolled-server
Date: Wed, 07 Apr 2010 15:12:30 GMT
Connection: Close
Content-Type: text/html
Content-Length: 82
Set-Cookie: a=1; Path=/; Secure, a=2; Path=/; Secure
</pre>
<p>
In this case Drakma has to choose whether cookie "a" has
the value "1" or "2". By default, Drakma will choose the
last value specified, in this case "2".
</p>
<p>
By default, Drakma conforms to <a
href="http://www.w3.org/Protocols/rfc2109/rfc2109">RFC2109
HTTP State Management Mechanism</a>, section 4.3.3 Cookie
Management:
<blockquote>
<em>
If a user agent receives a Set-Cookie response header
whose NAME is the same as a pre-existing cookie, and
whose Domain and Path attribute values exactly
(string) match those of a pre-existing cookie, the new
cookie supersedes the old.
</em>
</blockquote>
</p>
</clix:description>
</clix:special-variable>
</clix:subchapter>
<clix:subchapter name="conditions" title="Conditions">
<p>
This section lists all the condition types that are defined by
Drakma.
</p>
<clix:condition name="cookie-date-parse-error">
<clix:description>
<p>
Signalled if Drakma tries to parse the date of an incoming
cookie header and can't interpret it.
</p>
</clix:description>
</clix:condition>
<clix:condition name="cookie-error">
<clix:description>
<p>
Signalled if someone tries to create a COOKIE object
that's not valid.
</p>
</clix:description>
</clix:condition>
<clix:function name="cookie-error-cookie" generic="true">
<clix:lambda-list>cookie-error</clix:lambda-list>
<clix:returns>(or cookie null)</clix:returns>
<clix:description>
<p>
The <code>COOKIE</code> object that caused this error.
Can be <code>NIL</code> in case such an object couldn't be
initialized.
</p>
</clix:description>
</clix:function>
<clix:condition name="parameter-error">
<clix:description>
<p>
Signalled if a function was called with inconsistent or
illegal parameters.
</p>
</clix:description>
</clix:condition>
<clix:condition name="syntax-error">
<clix:description>
<p>
Signalled if Drakma encounters wrong or unknown syntax
when reading the reply from the server.
</p>
</clix:description>
</clix:condition>
<clix:condition name="drakma-condition">
<clix:description>
<p>
Superclass for all conditions related to Drakma.
</p>
</clix:description>
</clix:condition>
<clix:condition name="drakma-error">
<clix:description>
<p>
Superclass for all errors related to Drakma.
</p>
</clix:description>
</clix:condition>
<clix:condition name="drakma-warning">
<clix:description>
<p>
Superclass for all warnings related to Drakma.
</p>
</clix:description>
</clix:condition>
</clix:subchapter>
</clix:chapter>
<clix:chapter name="index" title="Symbol index">
<clix:index/>
</clix:chapter>
</clix:documentation>
| 77,435 | Common Lisp | .l | 1,620 | 39.271605 | 253 | 0.63353 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | f2bd9fef32bcb6eea34480db3d647ee40114f89ab17fa670d87e0f443dedf924 | 43,233 | [
-1
] |
43,234 | index.html | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/drakma-v2.0.9/docs/index.html | <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Strict//EN">
<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"></meta><title>Drakma - A Common Lisp HTTP client</title><meta name="description" content="
Drakma is a full-featured HTTP client implemented in Common Lisp.
It knows how to handle HTTP/1.1 chunking,
persistent connections, re-usable sockets, SSL, continuable uploads, file uploads, cookies, and more.
"></meta><style type="text/css">
body { background-color: #ffffff }
pre { padding:5px; background-color:#e0e0e0 }
pre.none { padding:5px; background-color:#ffffff }
h3, h4, h5 { text-decoration: underline; }
.entry-type { padding-left: 1em; font-size: 60%; font-style: italic }
a { text-decoration: none; padding: 1px 2px 1px 2px; }
a:visited { text-decoration: none; padding: 1px 2px 1px 2px; }
a:hover { text-decoration: none; padding: 1px 1px 1px 1px; border: 1px solid #000000; }
a:focus { text-decoration: none; padding: 1px 2px 1px 2px; border: none; }
a.none { text-decoration: none; padding: 0; }
a.none:visited { text-decoration: none; padding: 0; }
a.none:hover { text-decoration: none; border: none; padding: 0; }
a.none:focus { text-decoration: none; border: none; padding: 0; }
a.noborder { text-decoration: none; padding: 0; }
a.noborder:visited { text-decoration: none; padding: 0; }
a.noborder:hover { text-decoration: none; border: none; padding: 0; }
a.noborder:focus { text-decoration: none; border: none; padding: 0; }
</style></head><body>
<h2>Drakma - A Common Lisp HTTP client</h2>
<blockquote>
<h3 xmlns=""><a class="none" name="abstract">Abstract</a></h3>
<p>
Drakma is a full-featured HTTP client implemented in Common
Lisp. It knows how to handle <a href="#chunked">HTTP/1.1
chunking</a>, <a href="#arg-keep-alive">persistent
connections</a>, <a href="#ex-reuse-connection">re-usable
sockets</a>, <a href="#ex-chunked-https">SSL</a>, <a href="#ex-assemble-request-content">continuable uploads</a>,
<a href="#arg-parameters">file uploads</a>, <a href="#arg-cookie-jar">cookies</a>, and more.
</p>
<p>
The code comes with a <a href="http://www.opensource.org/licenses/bsd-license.php">BSD-style
license</a> so you can basically do with it whatever you want.
</p>
</blockquote>
<h3 xmlns=""><a class="none" name="contents">Contents</a></h3>
<ol xmlns="">
<li><a href="#abstract">Abstract</a></li>
<li><a href="#contents">Contents</a></li>
<li>
<a href="#examples">Examples</a><ol>
<li><a href="#ex-loading">Loading Drakma with Quicklisp</a></li>
<li><a href="#ex-logging">Log headers to the REPL output stream</a></li>
<li><a href="#ex-request-redirect">Requesting a page with redirection</a></li>
<li><a href="#ex-charsets">Requesting a page containing non-ASCII characters</a></li>
<li><a href="#ex-binary-data">Requesting binary data</a></li>
<li><a href="#ex-chunked-https">Chunked transfers and HTTPS</a></li>
<li><a href="#ex-fake-ua">Faking a user agent header</a></li>
<li><a href="#ex-post-and-cookie">Posting data and using cookies</a></li>
<li><a href="#ex-reuse-connection">Reusing a connection to a server</a></li>
<li><a href="#ex-basic-auth">Basic Authorization</a></li>
<li><a href="#ex-response-stream">Reading the response from a stream</a></li>
<li><a href="#ex-assemble-request-content">Piecemeal assembly of request contents</a></li>
<li><a href="#ex-partial-transfers">Partial transfers</a></li>
</ol>
</li>
<li><a href="#install">Download and Installation</a></li>
<li><a href="#patches">Development and patches</a></li>
<li>
<a href="#dictionary">The Drakma dictionary</a><ol>
<li><a href="#dict-request">Requests</a></li>
<li><a href="#headers">Headers</a></li>
<li><a href="#cookies">Cookies</a></li>
<li><a href="#conditions">Conditions</a></li>
</ol>
</li>
<li><a href="#index">Symbol index</a></li>
</ol>
<h3 xmlns=""><a class="none" name="examples">Examples</a></h3>
<style type="text/css">
body { margin-left: 2em; }
p, blockquote { max-width: 45em; }
pre { margin-left: 3em; margin-right: 3em; word-wrap: break-word; overflow-x: auto; background: #eee; }
.arglist-spacer { margin-left: 6em; max-width: 45em; }
.repl-output { color: black; }
.repl-input { font-weight: bold; }
.headers-out { color: SteelBlue; }
.headers-in { color: SeaGreen; }
</style>
<p>
Here is a collection of example uses of Drakma to which
demonstrate some of its features. In the examples, text is
color coded to indicate where it comes from (<tt><span class="repl-input">REPL input</span>, <span class="repl-output">REPL output</span>, <span class="headers-out">HTTP headers sent</span></tt> and <tt><span class="headers-in">HTTP headers received</span></tt>). Headers
particularly relevant to the example at hand are shown <tt><span class="headers-out"><b>in</b></span> <span class="headers-in"><b>bold</b></span></tt>.
</p>
<h4 xmlns=""><a name="ex-loading">Loading Drakma with Quicklisp</a></h4>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :drakma)</span>
<span class="repl-output">To load "drakma":
Load 1 ASDF system:
drakma
; Loading "drakma"
To load "cl+ssl":
Load 1 ASDF system:
flexi-streams
Install 8 Quicklisp releases:
alexandria babel bordeaux-threads cffi cl+ssl
trivial-features trivial-garbage trivial-gray-streams
...
; Loading "drakma"
(:DRAKMA)
</span>
</pre>
<h4 xmlns=""><a name="ex-logging">Log headers to the REPL output stream</a></h4>
<p>
In some of the following examples, the headers exchanged
between Drakma and the HTTP server should be shown, for
illustration purposes. This can be achieved like so:
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(setf drakma:*header-stream* *standard-output*)</span>
<span class="repl-output">#<SYNONYM-STREAM to *TERMINAL-IO* #x3020006AC7DD></span>
</pre>
<h4 xmlns=""><a name="ex-request-redirect">Requesting a page with redirection</a></h4>
<p>
Request a page. Note how Drakma automatically follows the 301
redirect and how the fourth return value shows the
<em>new</em> URI.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(<a href="#http-request">drakma:http-request</a> "http://lisp.org/")</span>
<span class="headers-out">GET / HTTP/1.1
Host: lisp.org
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 <b>307 Temporary Redirect</b>
Date: Sun, 09 Dec 2012 08:01:56 GMT
Connection: Close
Server: AllegroServe/1.2.65
Transfer-Encoding: chunked
<b>LOCATION: http://lisp.org/index.html</b>
</span>
<span class="headers-out"><b>GET /index.html HTTP/1.1</b>
Host: lisp.org
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:01:56 GMT
Connection: Close
Server: AllegroServe/1.2.65
Content-Type: text/html
Content-Length: 459
LAST-MODIFIED: Wed, 26 Oct 2011 02:26:26 GMT
</span>
<span class="repl-output">"<HTML>
<HEAD>
<title>John McCarthy, 1927-2011</title>
<STYLE type=\"text/css\">
BODY {text-align: center}
</STYLE>
</HEAD>
<BODY>
<h1>John McCarthy</h1>
<img src=\"jmccolor.jpg\" alt=\"a picture of John McCarthy, from his website\"/>
<h3>1927-2011</h3>
<br><br>
<a href=\"http://www-formal.stanford.edu/jmc/\">John McCarthy's Home Page</a><br>
<a href=\"http://news.stanford.edu/news/2011/october/john-mccarthy-obit-102511.html\">Obituary</a>
</BODY>
</HTML>
"
200
((:DATE . "Sun, 09 Dec 2012 08:01:56 GMT") (:CONNECTION . "Close") (:SERVER . "AllegroServe/1.2.65")
(:CONTENT-TYPE . "text/html") (:CONTENT-LENGTH . "459") (:LAST-MODIFIED . "Wed, 26 Oct 2011 02:26:26 GMT"))
#<URI http://lisp.org/index.html>
#<FLEXI-STREAMS:FLEXI-IO-STREAM #x30200155DB1D>
T
" OK"</span>
</pre>
<h4 xmlns=""><a name="ex-charsets">Requesting a page containing non-ASCII characters</a></h4>
<p>
Drakma automatically interprets the 'charset=utf-8' part
correctly.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(subseq (<a href="#http-request">drakma:http-request</a> "http://www.cl.cam.ac.uk/~mgk25/ucs/examples/digraphs.txt") 0 298)</span>
<span class="headers-out">GET /~mgk25/ucs/examples/digraphs.txt HTTP/1.1
Host: www.cl.cam.ac.uk
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:15:04 GMT
Server: Apache/2.2.3 (CentOS)
Last-Modified: Mon, 06 Apr 2009 18:13:43 GMT
ETag: "17cd62-298-466e6dbcd03c0"
Accept-Ranges: bytes
Content-Length: 664
X-UA-Compatible: IE=edge
Connection: close
<b>Content-Type: text/plain; charset=utf-8</b>
</span>
<span class="repl-output">"Latin Digraphs and Ligatures in ISO10646-1
A short table of ligatures and digraphs follows. Some of these may not be
ligatures/digraphs in the technical sense, (for example, æ is a seperate
letter in English), but visually they behave that way.
AÆE : U+00C6
aæe : U+00E6
ſßs : U+00DF
IIJJ : U+0132"</span>
</pre>
<h4 xmlns=""><a name="ex-binary-data">Requesting binary data</a></h4>
<p>
For non-textual content types, a vector of octets is returned.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(<a href="#http-request">drakma:http-request</a> "https://api.github.com/repos/edicl/drakma/git/tags/tag-does-not-exist")</span>
<span class="headers-out">GET /repos/edicl/drakma/git/tags/tag-does-not-exist HTTP/1.1
Host: api.github.com
User-Agent: Drakma/1.3.0 (SBCL 1.1.1.31.master.2-9fac43f-dirty; Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 404 Not Found
Server: nginx
Date: Fri, 28 Dec 2012 08:37:31 GMT
<b>Content-Type: application/json; charset=utf-8</b>
Connection: close
Status: 404 Not Found
X-GitHub-Media-Type: github.beta
X-RateLimit-Remaining: 48
X-RateLimit-Limit: 60
Content-Length: 23
X-Content-Type-Options: nosniff
Cache-Control:
</span>
<span class="repl-output">#(123 34 109 101 115 115 97 103 101 34 58 34 78 111 116 32 70 111 117 110 100 34 125)
404
((:SERVER . "nginx") (:DATE . "Fri, 28 Dec 2012 08:37:31 GMT") (:CONTENT-TYPE . "application/json; charset=utf-8")
(:CONNECTION . "close") (:STATUS . "404 Not Found") (:X-GITHUB-MEDIA-TYPE . "github.beta") (:X-RATELIMIT-REMAINING . "48")
(:X-RATELIMIT-LIMIT . "60") (:CONTENT-LENGTH . "23") (:X-CONTENT-TYPE-OPTIONS . "nosniff") (:CACHE-CONTROL . ""))
#<PURI:URI https://api.github.com/repos/edicl/drakma/git/tags/tag-does-not-exist>
#<FLEXI-STREAMS:FLEXI-IO-STREAM {101C40C043}>
T
"Not Found"</span>
<span class="repl-output">? </span><span class="repl-input">(<a href="http://weitz.de/flexi-streams/#octets-to-string" target="_new">flexi-streams:octets-to-string</a> *)</span>
<span class="repl-output">"{\"message\":\"Not Found\"}"</span></pre>
<h4 xmlns=""><a name="ex-chunked-https">Chunked transfers and HTTPS</a></h4>
<p>
Request a page using the HTTPS protocol. Also note that the
server uses <a name="chunked" href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.6.1">chunked
transfer encoding</a> for its reply
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :cl-ppcre)</span>
<span class="repl-output">? </span><span class="repl-input">(cl-ppcre:scan-to-strings "(?s)You have.*your data."
(<a href="#http-request">drakma:http-request</a> "https://www.fortify.net/cgi/ssl_2.pl"))</span>
<span class="headers-out">GET /cgi/ssl_2.pl HTTP/1.1
Host: www.fortify.net
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:15:31 GMT
Server: Apache
Connection: close
<b>Transfer-Encoding: chunked</b>
Content-Type: text/html
</span>
<span class="repl-output">"You have connected to this web server using the RC4-SHA encryption cipher
with a key length of 128 bits.
<p>
This is a high-grade encryption connection, regarded by most experts as being suitable
for sending or receiving even the most sensitive or valuable information
across a network.
<p>
In a crude analogy, using this cipher is similar to sending or storing your data inside
a high quality safe - compared to an export-grade cipher which is similar to using
a paper envelope to protect your data."
#()</span>
</pre>
<h4 xmlns=""><a name="ex-fake-ua">Faking a user agent header</a></h4>
<p>
Some servers adapt their behavior according to the Browser
that is used. Drakma can claim to be i.e. MS Internet
Explorer.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(cl-ppcre:scan-to-strings "<h4>.*" (<a href="#http-request">drakma:http-request</a> "http://whatsmyuseragent.com/" <a href="#arg-user-agent">:user-agent :explorer</a>))</span>
<span class="headers-out">GET / HTTP/1.1
Host: whatsmyuseragent.com
<b>User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)</b>
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:23:50 GMT
Server: Apache
X-Powered-By: PHP/5.2.17
Connection: close
Transfer-Encoding: chunked
Content-Type: text/html
</span>
<span class="repl-output">"<h4>Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)</h4>"
#()</span>
</pre>
<h4 xmlns=""><a name="ex-post-and-cookie">Posting data and using cookies</a></h4>
<p>
Drakma can send parameters in a POST request and knows how to
deal with <a href="#cookie">cookies</a>. Note how Drakma
sends the cookie back in the second request.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((cookie-jar (make-instance <a href="#cookie-jar">'drakma:cookie-jar</a>)))
(<a href="#http-request">drakma:http-request</a> "http://www.phpsecurepages.com/test/test.php"
<a href="#arg-method">:method :post</a>
<a href="#arg-parameters">:parameters '(("entered_login" . "test")
("entered_password" . "test"))</a>
<a href="#arg-cookie-jar">:cookie-jar cookie-jar</a>)
(<a href="#http-request">drakma:http-request</a> "http://www.phpsecurepages.com/test/test2.php"
<a href="#arg-cookie-jar">:cookie-jar cookie-jar</a>)
(<a href="#cookie-jar-cookies">drakma:cookie-jar-cookies</a> cookie-jar))</span>
<span class="headers-out">POST /test/test.php HTTP/1.1
Host: www.phpsecurepages.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 40
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:13 GMT
Server:
X-Powered-By: PHP/5.2.17
<b>Set-Cookie: PHPSESSID=vijk3706eojs7n8u5cdpi3ju05; path=/</b>
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
X-Powered-By: PleskLin
Content-Length: 4479
Connection: close
Content-Type: text/html
</span>
<span class="headers-out">GET /test/test2.php HTTP/1.1
Host: www.phpsecurepages.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
<b>Cookie: PHPSESSID=vijk3706eojs7n8u5cdpi3ju05</b>
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:16 GMT
Server:
X-Powered-By: PHP/5.2.17
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
X-Powered-By: PleskLin
Content-Length: 4479
Connection: close
Content-Type: text/html
</span>
<span class="repl-output">(#<COOKIE PHPSESSID=vijk3706eojs7n8u5cdpi3ju05; path=/; domain=www.phpsecurepages.com>)</span>
</pre>
<h4 xmlns=""><a name="ex-reuse-connection">Reusing a connection to a server</a></h4>
<p>
Drakma can <a name="re-use">use</a> a connection to a server for multiple requests.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((stream (nth-value 4 (<a href="#http-request">drakma:http-request</a> "http://www.lispworks.com/" <a href="#arg-close">:close nil</a>))))
(nth-value 2 (<a href="#http-request">drakma:http-request</a> "http://www.lispworks.com/success-stories/index.html"
<a href="#arg-stream">:stream stream</a>)))</span>
<span class="headers-out">GET / HTTP/1.1
Host: www.lispworks.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:56 GMT
Server: Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9
Last-Modified: Tue, 20 Nov 2012 12:27:40 GMT
ETag: "336280-28eb-4ceec5c1f4700"
Accept-Ranges: bytes
Content-Length: 10475
Content-Type: text/html
</span>
<span class="headers-out">GET /success-stories/index.html HTTP/1.1
Host: www.lispworks.com
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
<b>Connection: close</b>
</span>
<span class="headers-in">HTTP/1.1 200 OK
Date: Sun, 09 Dec 2012 08:25:56 GMT
Server: Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9
Last-Modified: Tue, 20 Nov 2012 12:28:52 GMT
ETag: "336386-2940-4ceec6069e900"
Accept-Ranges: bytes
Content-Length: 10560
<b>Connection: close</b>
Content-Type: text/html
</span>
<span class="repl-output">((:DATE . "Sun, 09 Dec 2012 08:25:56 GMT")
(:SERVER . "Apache/2.2.22 (Unix) mod_ssl/2.2.22 OpenSSL/1.0.1c mod_apreq2-20051231/2.6.0 mod_perl/2.0.5 Perl/v5.8.9")
(:LAST-MODIFIED . "Tue, 20 Nov 2012 12:28:52 GMT") (:ETAG . "\"336386-2940-4ceec6069e900\"") (:ACCEPT-RANGES . "bytes")
(:CONTENT-LENGTH . "10560") (:CONNECTION . "close") (:CONTENT-TYPE . "text/html"))</span>
</pre>
<h4 xmlns=""><a name="ex-basic-auth">Basic Authorization</a></h4>
<p>
Drakma supports basic authorization. In this example, we use
a locally running <a href="http://weitz.de/hunchentoot">Hunchentoot</a> server.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(ql:quickload :hunchentoot-test)</span>
<span class="repl-output">To load "hunchentoot-test":
Load 4 ASDF systems:
cl-ppcre cl-who drakma hunchentoot
Install 1 Quicklisp release:
hunchentoot
...
; Loading "hunchentoot-test"
(:HUNCHENTOOT-TEST)
? </span><span class="repl-input">(hunchentoot:start (make-instance 'hunchentoot:easy-acceptor :port 4242))</span>
<span class="repl-output">#<EASY-ACCEPTOR (host *, port 4242)>
? </span><span class="repl-input">(nth-value 1 (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/authorization.html"))</span>
<span class="headers-out">GET /hunchentoot/test/authorization.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="repl-output">127.0.0.1 - [2012-12-09 09:27:40] "GET /hunchentoot/test/authorization.html HTTP/1.1" 401 543 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 <b>401 Authorization Required</b>
Content-Length: 543
Date: Sun, 09 Dec 2012 08:27:40 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Www-Authenticate: Basic realm="Hunchentoot"
Content-Type: text/html; charset=iso-8859-1
</span>
<span class="repl-output">401
? </span><span class="repl-input">(nth-value 1 (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/authorization.html"
<a href="#arg-basic-authorization">:basic-authorization '("nanook" "igloo")</a>))</span>
<span class="headers-out">GET /hunchentoot/test/authorization.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
<b>Authorization: Basic bmFub29rOmlnbG9v</b>
Accept: */*
Connection: close
</span>
<span class="repl-output">127.0.0.1 nanook [2012-12-09 09:28:15] "GET /hunchentoot/test/authorization.html HTTP/1.1" 200 907 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 200 OK
Content-Length: 907
Date: Sun, 09 Dec 2012 08:28:15 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Content-Type: text/html; charset=utf-8
</span>
<span class="repl-output">200</span>
</pre>
<h4 xmlns=""><a name="ex-response-stream">Reading the response from a stream</a></h4>
<p>
Drakma can return a stream to the application so that the
reply is not completely buffered in memory first.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((stream (<a href="#http-request">drakma:http-request</a> "https://api.github.com/orgs/edicl/public_members"
<b>:want-stream t</b>)))
(setf (<a href="http://weitz.de/flexi-streams/#flexi-stream-external-format" target="_new">flexi-streams:flexi-stream-external-format</a> stream) :utf-8)
(<a href="http://common-lisp.net/project/yason/#parse" target="_new">yason:parse</a> stream :object-as :plist))</span>
<span class="headers-out">GET /orgs/edicl/public_members HTTP/1.1
Host: api.github.com
User-Agent: Drakma/1.3.0 (SBCL 1.1.1.31.master.2-9fac43f-dirty; Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
</span>
<span class="headers-in">HTTP/1.1 200 OK
Server: nginx
Date: Fri, 28 Dec 2012 10:27:34 GMT
Content-Type: application/json; charset=utf-8
Connection: close
Status: 200 OK
Last-Modified: Sat, 22 Dec 2012 18:39:14 GMT
X-Content-Type-Options: nosniff
X-RateLimit-Limit: 60
X-GitHub-Media-Type: github.beta
Vary: Accept
Content-Length: 1899
Cache-Control: public, max-age=60, s-maxage=60
ETag: "66a5dd35e79146a53029a1807293f9d3"
X-RateLimit-Remaining: 56
</span>
<span class="repl-output">(("type" "User" "repos_url" "https://api.github.com/users/hanshuebner/repos" "followers_url"
"https://api.github.com/users/hanshuebner/followers" "login" "hanshuebner" "gists_url"
"https://api.github.com/users/hanshuebner/gists{/gist_id}" "following_url"
"https://api.github.com/users/hanshuebner/following" "events_url"
"https://api.github.com/users/hanshuebner/events{/privacy}" "organizations_url"
"https://api.github.com/users/hanshuebner/orgs" "received_events_url"
"https://api.github.com/users/hanshuebner/received_events" "url"
"https://api.github.com/users/hanshuebner" "avatar_url"
"https://secure.gravatar.com/avatar/280d76aa82179ae04550534649de1e6e?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png"
"subscriptions_url" "https://api.github.com/users/hanshuebner/subscriptions" "starred_url"
"https://api.github.com/users/hanshuebner/starred{/owner}{/repo}" "id" 108751 "gravatar_id"
"280d76aa82179ae04550534649de1e6e")
("type" "User" "repos_url" "https://api.github.com/users/nhabedi/repos" "followers_url"
"https://api.github.com/users/nhabedi/followers" "login" "nhabedi" "gists_url"
"https://api.github.com/users/nhabedi/gists{/gist_id}" "following_url"
"https://api.github.com/users/nhabedi/following" "events_url"
"https://api.github.com/users/nhabedi/events{/privacy}" "organizations_url"
"https://api.github.com/users/nhabedi/orgs" "received_events_url"
"https://api.github.com/users/nhabedi/received_events" "url"
"https://api.github.com/users/nhabedi" "avatar_url"
"https://secure.gravatar.com/avatar/24c09c7b0b2c0481283d854bacdd7926?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-user-420.png"
"subscriptions_url" "https://api.github.com/users/nhabedi/subscriptions" "starred_url"
"https://api.github.com/users/nhabedi/starred{/owner}{/repo}" "id" 537618 "gravatar_id"
"24c09c7b0b2c0481283d854bacdd7926"))</span>
</pre>
<h4 xmlns=""><a name="ex-assemble-request-content">Piecemeal assembly of request contents</a></h4>
<p>
Request contents can be assembled from various sources, and
chunked encoding can be used by request bodies. Many servers
do not support chunked encoding for request bodies, though.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(let ((temp-file (ensure-directories-exist #p"/tmp/quux.txt"))
(continuation (<a href="#http-request">drakma:http-request</a> "http://localhost:4242/hunchentoot/test/parameter_latin1_post.html"
<a href="#arg-method">:method :post</a>
<a href="#arg-content">:content :continuation</a>)))
(funcall continuation "foo=" t)
(funcall continuation (list (char-code #\z) (char-code #\a)) t)
(funcall continuation (lambda (stream)
(write-char #\p stream)) t)
(with-open-file (out temp-file
:direction :output
:if-does-not-exist :create
:if-exists :supersede)
(write-string "p" out))
(funcall continuation temp-file t)
(cl-ppcre:scan-to-strings "zappzerapp" (funcall continuation "zerapp")))</span>
<span class="headers-out">POST /hunchentoot/test/parameter_latin1_post.html HTTP/1.1
Host: localhost:4242
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
Content-Type: application/x-www-form-urlencoded
<b>Transfer-Encoding: chunked</b>
</span>
<span class="repl-output">127.0.0.1 - [2012-12-09 10:06:44] "POST /hunchentoot/test/parameter_latin1_post.html HTTP/1.1" 200 1312 "-" "Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)"</span>
<span class="headers-in">HTTP/1.1 200 OK
Content-Length: 1312
Date: Sun, 09 Dec 2012 09:06:44 GMT
Server: Hunchentoot 1.2.5
Connection: Close
Last-Modified: Sun, 09 Dec 2012 09:06:44 GMT
Pragma: no-cache
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Expires: Mon, 26 Jul 1997 05:00:00 GMT
Content-Type: text/html; charset=ISO-8859-1
</span>
<span class="repl-output">"zappzerapp"
#()</span>
</pre>
<h4 xmlns=""><a name="ex-partial-transfers">Partial transfers</a></h4>
<p>
<a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35" target="_new">Partial transfers</a> of resources are possible.
</p>
<pre><span class="repl-output">? </span><span class="repl-input">(cl-ppcre:regex-replace-all
"<.*?>"
(format nil "~A~%~A"
(<a href="#http-request">drakma:http-request</a> "http://members.shaw.ca/mitb/hunchentoot.html"
<a href="#arg-range">:range '(998 1034)</a>)
(<a href="#http-request">drakma:http-request</a> "http://members.shaw.ca/mitb/hunchentoot.html"
<a href="#arg-range">:range '(1213 1249)</a>))
"")</span>
<span class="headers-out">GET /mitb/hunchentoot.html HTTP/1.1
Host: members.shaw.ca
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
<b>Range: bytes=998-1034</b>
</span>
<span class="headers-in">HTTP/1.1 206 Partial Content
Date: Sun, 09 Dec 2012 09:16:16 GMT
Server: Apache/2.2.20 (Unix) mod_ldap_userdir/1.1.17
Last-Modified: Wed, 14 Mar 2012 23:22:04 GMT
ETag: "3b7eed-3238-4bb3c3e453f00"
Accept-Ranges: bytes
Content-Length: 37
<b>Content-Range: bytes 998-1034/12856</b>
Content-Type: text/html
Connection: close
</span>
<span class="headers-out">GET /mitb/hunchentoot.html HTTP/1.1
Host: members.shaw.ca
User-Agent: Drakma/1.3.0 (Clozure Common Lisp Version 1.8-r15286M (DarwinX8664); Darwin; 12.2.0; http://weitz.de/drakma/)
Accept: */*
Connection: close
<b>Range: bytes=1213-1249</b>
</span>
<span class="headers-in">HTTP/1.1 206 Partial Content
Date: Sun, 09 Dec 2012 09:16:16 GMT
Server: Apache/2.2.20 (Unix) mod_ldap_userdir/1.1.17
Last-Modified: Wed, 14 Mar 2012 23:22:04 GMT
ETag: "3b7eed-3238-4bb3c3e453f00"
Accept-Ranges: bytes
Content-Length: 37
<b>Content-Range: bytes 1213-1249/12856</b>
Content-Type: text/html
</span>
<span class="repl-output">"DRAKMA (Queen of Cosmic Greed)
HUNCHENTOOT (The Giant Spider)"
T</span>
</pre>
<h3 xmlns=""><a class="none" name="install">Download and Installation</a></h3>
<p>
Drakma depends on a number of open source libraries, so the
preferred method to download, compile and load it is via <a href="http://www.quicklisp.org/">Quicklisp</a>. Drakma's
current version number is 2.0.4.
</p>
<p>
The canonical location for the latest version of Drakma is <a href="http://weitz.de/files/drakma.tar.gz">http://weitz.de/files/drakma.tar.gz</a>.
</p>
<h3 xmlns=""><a class="none" name="patches">Development and patches</a></h3>
<p>
The development version of Drakma can be found <a href="https://github.com/edicl/drakma" target="_new">on
github</a>. Please use the github issue tracking system to
submit bug reports. Patches are welcome, please use <a href="https://github.com/edicl/drakma/pulls">GitHub pull
requests</a>. If you want to make a change, please <a href="http://weitz.de/patches.html" target="_new">read this
first</a>.
</p>
<h3 xmlns=""><a class="none" name="dictionary">The Drakma dictionary</a></h3>
<h4 xmlns=""><a name="dict-request">Requests</a></h4>
<p>
The <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> function is the heart of
Drakma. It is used to send requests to web servers and will
either return the message body of the server's reply or (if
the user so wishes) a stream one can read from. The wealth of
keyword parameters might look a bit intimidating first, but
you will rarely need more than two or three of them - the
default behavior of Drakma is (hopefully) designed to do The
Right Thing[TM] in most cases.
</p>
<p>
You can use the <code xmlns=""><a href="#*header-stream*">*HEADER-STREAM*</a></code> variable
to debug requests handled by Drakma in a way similar to <a href="http://livehttpheaders.mozdev.org/">LiveHTTPHeaders</a>.
</p>
<p xmlns=""><a class="none" name="http-request"></a><clix:special-definition xmlns:clix="http://bknr.net/clixdoc">
[Function]<br xmlns="http://www.w3.org/1999/xhtml"></br>
<b xmlns="http://www.w3.org/1999/xhtml">http-request</b> <i xmlns="http://www.w3.org/1999/xhtml">uri</i><div xmlns="http://www.w3.org/1999/xhtml" class="arglist-spacer">&rest args</div>
<div xmlns="http://www.w3.org/1999/xhtml" class="arglist-spacer">&key
<a href="#arg-protocol">protocol</a>
<a href="#arg-method">method</a>
<a href="#arg-force-ssl">force-ssl</a>
<a href="#arg-certificate">certificate</a>
<a href="#arg-key">key</a>
<a href="#arg-certificate-password">certificate-password</a>
<a href="#arg-verify">verify</a>
<a href="#arg-max-depth">max-depth</a>
<a href="#arg-ca-file">ca-file</a>
<a href="#arg-ca-directory">ca-directory</a>
<a href="#arg-parameters">parameters</a>
<a href="#arg-url-encoder">url-encoder</a>
<a href="#arg-content">content</a>
<a href="#arg-content-type">content-type</a>
<a href="#arg-content-length">content-length</a>
<a href="#arg-form-data">form-data</a>
<a href="#arg-cookie-jar">cookie-jar</a>
<a href="#arg-basic-authorization">basic-authorization</a>
<a href="#arg-user-agent">user-agent</a>
<a href="#arg-accept">accept</a>
<a href="#arg-range">range</a>
<a href="#arg-proxy">proxy</a>
<a href="#arg-proxy-basic-authorization">proxy-basic-authorization</a>
<a href="#arg-real-host">real-host</a>
<a href="#arg-additional-headers">additional-headers</a>
<a href="#arg-redirect">redirect</a>
<a href="#arg-auto-referer">auto-referer</a>
<a href="#arg-keep-alive">keep-alive</a>
<a href="#arg-close">close</a>
<a href="#arg-external-format-out">external-format-out</a>
<a href="#arg-external-format-in">external-format-in</a>
<a href="#arg-force-binary">force-binary</a>
<a href="#arg-want-stream">want-stream</a>
<a href="#arg-stream">stream</a>
<a href="#arg-preserve-uri">preserve-uri</a>
<a href="#arg-connection-timeout">connection-timeout</a>
<a href="#arg-deadline">deadline</a>
</div>
<div xmlns="http://www.w3.org/1999/xhtml" class="arglist-spacer">
=> body-or-stream<sup>0</sup>, status-code<sup>1</sup>,
headers<sup>2</sup>, uri<sup>3</sup>, stream<sup>4</sup>,
<a href="#arg-want-stream">must-close<sup>5</sup></a>,
reason-phrase<sup>6</sup>
</div>
</clix:special-definition><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Sends an <a href="http://www.w3.org/Protocols/rfc2616/rfc2616.html">HTTP</a>
request to a web server and returns its reply.
<code xmlns=""><i>uri</i></code> is where the request is sent to,
and it is either a string denoting a uniform resource
identifier or a <code>PURI:URI</code> object. The scheme
of <code xmlns=""><i>uri</i></code> must be `http' or `https'.
The function returns SEVEN values - the body of the
reply<sup>0</sup> (but see below), the status
code<sup>1</sup> as an integer, an alist of the
headers<sup>2</sup> sent by the server where for each
element the car (the name of the header) is a keyword and
the cdr (the value of the header) is a string, the
uri<sup>3</sup> the reply comes from (which might be
different from the <code xmlns=""><i>uri</i></code> the request
was sent to in case of redirects), the stream<sup>4</sup>
the reply was read from, a generalized boolean<sup>5</sup>
which denotes whether the stream should be closed (and
which you can usually ignore), and finally the reason
phrase<sup>6</sup> from the status line as a string.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-protocol"></a>
<code xmlns=""><i>protocol</i></code> is the HTTP protocol version
which is going to be used in the request line. It must be
one of the keywords <code>:HTTP/1.0</code> or
<code>:HTTP/1.1</code>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-method"></a>
<code xmlns=""><i>method</i></code> is the method used in the
request line, a keyword (like <code>:GET</code> or
<code>:HEAD</code>) denoting a valid HTTP/1.1 or WebDAV
request method, or <code>:REPORT</code>, as described in
the Versioning Extensions to WebDAV. Additionally, you
can also use the pseudo method <code>:OPTIONS*</code>
which is like <code>:OPTIONS</code> but means that an
"OPTIONS *" request line will be sent, i.e. the
<code xmlns=""><i>uri</i></code>'s path and query parts will be
ignored.
</p>
<p xmlns="http://www.w3.org/1999/xhtml"><a name="arg-force-ssl"></a>
If <code xmlns=""><i>force-ssl</i></code> is true, SSL will be
attached to the socket stream which connects Drakma with
the web server. Usually, you don't have to provide this
argument, as SSL will be attached anyway if the scheme of
<code xmlns=""><i>uri</i></code> is `https'.
</p>
<p xmlns="http://www.w3.org/1999/xhtml"><a name="arg-certificate"></a><a name="arg-certificate-password"></a><a name="arg-key"></a>
<code xmlns=""><i>certificate</i></code> is the file name of the PEM
encoded client certificate to present to the server when
making a SSL connection. <code xmlns=""><i>key</i></code> specifies
the file name of the PEM encoded private key matching the
certificate. <code xmlns=""><i>certificate-password</i></code>
specifies the pass phrase to use to decrypt the private key.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-verify"></a>
<code xmlns=""><i>verify</i></code> can be specified to force
verification of the certificate that is presented by the
server in an SSL connection. It can be specified either
as <code>NIL</code> if no check should be performed,
<code>:OPTIONAL</code> to verify the server's certificate
if it presented one or <code>:REQUIRED</code> to verify
the server's certificate and fail if an invalid or no
certificate was presented.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-max-depth"></a>
<code xmlns=""><i>max-depth</i></code> can be specified to change
the maximum allowed certificate signing depth that is
accepted. The default is 10.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-ca-file"></a>
<a name="arg-ca-directory"></a>
<code xmlns=""><i>ca-file</i></code> and
<code xmlns=""><i>ca-directory</i></code> can be specified to set
the certificate authority bundle file or directory to use
for certificate validation.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
The <code xmlns=""><i>certificate</i></code>,
<code xmlns=""><i>key</i></code>,
<code xmlns=""><i>certificate-password</i></code>,
<code xmlns=""><i>verify</i></code>,
<code xmlns=""><i>max-depth</i></code>,
<code xmlns=""><i>ca-file</i></code> and
<code xmlns=""><i>ca-directory</i></code> parameters are ignored
for non-SSL requests. They are also ignored on LispWorks.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-parameters"></a>
<a name="arg-form-data"></a>
<code xmlns=""><i>parameters</i></code> is an alist of name/value
pairs (the car and the cdr each being a string) which
denotes the parameters which are added to the query part
of the URL or (in the case of a POST request) comprise the
body of the request. (But see
<code xmlns=""><i>content</i></code> below.) The values can also
be <code>NIL</code> in which case only the name (without
an equal sign) is used in the query string. The
name/value pairs are URL-encoded using the FLEXI-STREAMS
external format <code xmlns=""><i>external-format-out</i></code>
before they are sent to the server unless
<code xmlns=""><i>form-data</i></code> is true in which case the
POST request body is sent as `multipart/form-data' using
<code xmlns=""><i>external-format-out</i></code>. The values of
the <code xmlns=""><i>parameters</i></code> alist can also be
pathnames, open binary input streams, unary functions, or
lists where the first element is of one of the former
types. These values denote files which should be sent as
part of the request body. If files are present in
<code xmlns=""><i>parameters</i></code>, the content type of the
request is always `multipart/form-data'. If the value is
a list, the part of the list behind the first element is
treated as a plist which can be used to specify a content
type and/or a filename for the file, i.e. such a value
could look like, e.g., <tt>(#p"/tmp/my_file.doc"
:content-type "application/msword" :filename
"upload.doc")</tt>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-url-encoder"></a>
<code xmlns=""><i>url-encoder</i></code> specifies a custom URL
encoder function which will be used by drakma to
URL-encode parameter names and values. It needs to be a
function of two arguments. The arguments are the string
to encode and the external format to use (as accepted by
FLEXI-STREAMS:STRING-TO-OCTETS). The return value must be
the URL-encoded string. This can be used if specific
encoding rules are required.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-content"></a>
<a name="arg-external-format-out"></a>
<code xmlns=""><i>content</i></code>, if not <code>NIL</code>, is
used as the request body - <code xmlns=""><i>parameters</i></code>
is ignored in this case. <code xmlns=""><i>content</i></code> can
be a string, a sequence of octets, a pathname, an open
binary input stream, or a function designator. If
<code xmlns=""><i>content</i></code> is a sequence, it will be
directly sent to the server (using
<code xmlns=""><i>external-format-out</i></code> in the case of
strings). If <code xmlns=""><i>content</i></code> is a pathname,
the binary contents of the corresponding file will be sent
to the server. If <code xmlns=""><i>content</i></code> is a
stream, everything that can be read from the stream until
EOF will be sent to the server. If
<code xmlns=""><i>content</i></code> is a function designator, the
corresponding function will be called with one argument,
the stream to the server, to which it should send data.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
Finally, <code xmlns=""><i>content</i></code> can also be the
keyword <code>:CONTINUATION</code> in which case
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> returns only one value -
a `continuation' function. This function has one required
argument and one optional argument. The first argument
will be interpreted like <code xmlns=""><i>content</i></code>
above (but it cannot be a keyword), i.e. it will be sent
to the server according to its type. If the second
argument is true, the continuation function can be called
again to send more content, if it is <code>NIL</code> the
continuation function returns what
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> would have returned.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>content</i></code> is a sequence, Drakma will
use LENGTH to determine its length and will use the result
for the `Content-Length' header sent to the server. You
can overwrite this with the
<code xmlns=""><i>content-length</i></code> parameter (a
non-negative integer) which you can also use for the cases
where Drakma can't or won't determine the content length
itself. You can also explicitly provide a
<code xmlns=""><i>content-length</i></code> argument of
<code>NIL</code> which will imply that no `Content-Length'
header will be sent in any case. If no `Content-Length'
header is sent, Drakma will use chunked encoding to send
the content body. Note that this will not work with older
web servers.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-content-length"></a>
Providing a true <code xmlns=""><i>content-length</i></code>
argument which is not a non-negative integer means that
Drakma /must/ build the request body in RAM and compute
the content length even if it would have otherwise used
chunked encoding, for example in the case of file uploads.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-content-type"></a>
<code xmlns=""><i>content-type</i></code> is the corresponding
`Content-Type' header to be sent and will be ignored
unless <code xmlns=""><i>content</i></code> is provided as well.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
Note that a query already contained in
<code xmlns=""><i>uri</i></code> will always be sent with the
request line anyway in addition to other parameters sent
by Drakma.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-cookie-jar"></a>
<code xmlns=""><i>cookie-jar</i></code> is a cookie jar containing
cookies which will potentially be sent to the server (if
the domain matches, if they haven't expired, etc.) - this
cookie jar will be modified according to the `Set-Cookie'
header(s) sent back by the server.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-basic-authorization"></a>
<code xmlns=""><i>basic-authorization</i></code>, if not
<code>NIL</code>, should be a list of two strings
(username and password) which will be sent to the server
for basic authorization.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-user-agent"></a>
<code xmlns=""><i>user-agent</i></code>, if not <code>NIL</code>,
denotes which `User-Agent' header will be sent with the
request. It can be one of the keywords
<code>:DRAKMA</code>, <code>:FIREFOX</code>,
<code>:EXPLORER</code>, <code>:OPERA</code>, or
<code>:SAFARI</code> which denote the current version of
Drakma or, in the latter four cases, a fixed string
corresponding to a more or less recent (as of August 2006)
version of the corresponding browser. Or it can be a
string which is used directly.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-accept"></a>
<code xmlns=""><i>accept</i></code>, if not <code>NIL</code>,
specifies the contents of the `Accept' header sent.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-range"></a>
<code xmlns=""><i>range</i></code> optionally specifies a subrange
of the resource to be requested. It must be specified as
a list of two integers which indicate the start and
(inclusive) end offset of the requested range, in bytes
(i.e. octets).
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-proxy"></a>
<a name="arg-proxy-basic-authorization"></a>
If <code xmlns=""><i>proxy</i></code> is not <code>NIL</code>, it
should be a string denoting a proxy server through which
the request should be sent. Or it can be a list of two
values - a string denoting the proxy server and an integer
denoting the port to use (which will default to 80
otherwise). Defaults to
<code xmlns=""><i>*default-http-proxy*</i></code>.
<code xmlns=""><i>proxy-basic-authorization</i></code> is used
like <code xmlns=""><i>basic-authorization</i></code>, but for the
proxy, and only if <code xmlns=""><i>proxy</i></code> is true. If
the host portion of the uri is present in the
<code xmlns=""><a href="#*no-proxy-domains*">*NO-PROXY-DOMAINS*</a></code> or the
<code xmlns=""><i>NO-PROXY-DOMAINS</i></code> list then the proxy
setting will be ignored for this request.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>NO-PROXY-DOMAINS</i></code> is set then it
will supersede the <code xmlns=""><a href="#*no-proxy-domains*">*NO-PROXY-DOMAINS*</a></code>
variable. Inserting domains into this list will allow them
to ignore the proxy setting.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-real-host"></a>
If <code xmlns=""><i>real-host</i></code> is not <code>NIL</code>,
request is sent to the denoted host instead of the
<code xmlns=""><i>uri</i></code> host. When specified,
<code xmlns=""><i>real-host</i></code> supersedes
<code xmlns=""><i>proxy</i></code>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-additional-headers"></a>
<code xmlns=""><i>additional-headers</i></code> is a name/value
alist of additional HTTP headers which should be sent with
the request. Unlike in <code xmlns=""><i>parameters</i></code>,
the cdrs can not only be strings but also designators for
unary functions (which should in turn return a string) in
which case the function is called each time the header is
written.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-redirect"></a>
<a name="arg-auto-referer"></a>
If <code xmlns=""><i>redirect</i></code> is not <code>NIL</code>,
it must be a non-negative integer or T. If
<code xmlns=""><i>redirect</i></code> is true, Drakma will follow
redirects (return codes 301, 302, 303, or 307) unless
<code xmlns=""><i>redirect</i></code> is 0. If
<code xmlns=""><i>redirect</i></code> is an integer, it will be
decreased by 1 with each redirect. Furthermore, if
<code xmlns=""><i>auto-referer</i></code> is true when following
redirects, Drakma will populate the `Referer' header with
the <code xmlns=""><i>uri</i></code> that triggered the
redirection, overwriting an existing `Referer' header (in
<code xmlns=""><i>additional-headers</i></code>) if necessary.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-keep-alive"></a>
<a name="arg-close"></a>
If <code xmlns=""><i>keep-alive</i></code> is T, the server will
be asked to keep the connection alive, i.e. not to close
it after the reply has been sent. (Note that this not
necessary if both the client and the server use HTTP 1.1.)
If <code xmlns=""><i>close</i></code> is T, the server is
explicitly asked to close the connection after the reply
has been sent. <code xmlns=""><i>keep-alive</i></code> and
<code xmlns=""><i>close</i></code> are obviously mutually
exclusive.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-external-format-in"></a>
<a name="arg-force-binary"></a>
If the message body sent by the server has a text content
type, Drakma will try to return it as a Lisp string.
It'll first check if the `Content-Type' header denotes an
encoding to be used, or otherwise it will use the
<code xmlns=""><i>external-format-in</i></code> argument. The
body is decoded using FLEXI-STREAMS. If FLEXI-STREAMS
doesn't know the external format, the body is returned as
an array of octets. If the body is empty, Drakma will
return <code>NIL</code>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
If the message body doesn't have a text content type or if
<code xmlns=""><i>force-binary</i></code> is true, the body is
always returned as an array of octets.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-want-stream"></a>
If <code xmlns=""><i>want-stream</i></code> is true, the message
body is NOT read and instead the (open) socket stream is
returned as the first return value. If the sixth value of
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> is true, the stream
should be closed (and not be re-used) after the body has
been read. The stream returned is a <a href="http://weitz.de/flexi-streams/">flexi-stream</a>
with a <a href="http://weitz.de/chunga/" target="_new">chunked stream</a> as its underlying stream.
If you want to read binary data from this stream, read
from the underlying stream which you can get with
FLEXI-STREAM-STREAM.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-stream"></a>
Drakma will usually create a new socket connection for
each HTTP request. However, you can use the
<code xmlns=""><i>stream</i></code> argument to provide an open
socket stream which should be re-used.
<code xmlns=""><i>stream</i></code> MUST be a stream returned by a
previous invocation of <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>
where the sixth return value wasn't true. Obviously, it
must also be connected to the correct server and at the
right position (i.e. the message body, if any, must have
been read). Drakma will NEVER attach SSL to a stream
provided as the <code xmlns=""><i>stream</i></code> argument.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-connection-timeout"></a>
<code xmlns=""><i>connection-timeout</i></code> is the time (in
seconds) Drakma will wait until it considers an attempt to
connect to a server as a failure. It is supported only on
some platforms (currently abcl, clisp, LispWorks, mcl,
openmcl and sbcl). READ-TIMEOUT and WRITE-TIMEOUT are the
read and write timeouts (in seconds) for the socket stream
to the server. All three timeout arguments can also be
<code>NIL</code> (meaning no timeout), and they don't
apply if an existing stream is re-used. READ-TIMEOUT
argument is only available for LispWorks, WRITE-TIMEOUT is
only available for LispWorks 5.0 or higher.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-deadline"></a>
<code xmlns=""><i>deadline</i></code>, a time in the future,
specifies the time until which the request should be
finished. The deadline is specified in internal time
units. If the server fails to respond until that time, a
COMMUNICATION-DEADLINE-EXPIRED condition is signalled.
<code xmlns=""><i>deadline</i></code> is only available on CCL 1.2
and later.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<a name="arg-preserve-uri"></a>
If <code xmlns=""><i>preserve-uri</i></code> is not
<code>NIL</code>, the given <code xmlns=""><i>uri</i></code> will
not be processed. This means that the
<code xmlns=""><i>uri</i></code> will be sent as-is to the remote
server and it is the responsibility of the client to make
sure that all parameters are encoded properly. Note that
if this parameter is given, and the request is not a POST
with a content-type of `multipart/form-data',
<code xmlns=""><i>parameters</i></code> will not be used.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>decode-content</i></code> is not
<code>NIL</code>, then the content will automatically be
decoded according to any encodings specified in the
Content-Encoding header. The actual decoding is done by
the <code xmlns=""><a href="#decode-stream">decode-stream</a></code> generic function,
and you can implement new methods to support additional
encodings. Any encodings in Transfer-Encoding, such as
chunking, are always performed.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="parameter-present-p"></a>
[Function]
<br><b>parameter-present-p</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">name parameters</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">boolean</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>parameters</i></code> is an alist of
parameters as returned by, for example,
READ-TOKENS-AND-PARAMETERS and <code xmlns=""><i>name</i></code>
is a string naming a parameter, this function returns the
full parameter (name and value) - or <code>NIL</code> if
it's not in <code xmlns=""><i>parameters</i></code>.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="parameter-value"></a>
[Function]
<br><b>parameter-value</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">name parameters</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or string null)</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>parameters</i></code> is an alist of
parameters as returned by, for example,
READ-TOKENS-AND-PARAMETERS and <code xmlns=""><i>name</i></code>
is a string naming a parameter, this function returns the
value of this parameter - or <code>NIL</code> if it's not
in <code xmlns=""><i>parameters</i></code>.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="url-encode"></a>
[Function]
<br><b>url-encode</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">string external-format</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">string</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Returns a URL-encoded version of the string
<code xmlns=""><i>string</i></code> using the external format
<code xmlns=""><i>external-format</i></code>.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="decode-stream"></a>
[Function]
<br><b>decode-stream</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">encoding-type stream</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">stream</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Generic function to decode a stream. This is a generic
function which decodes the stream based on the
encoding-type. If a response contains one or more
transfer or content encodings, then decode-stream is
called for each encoding type in the correct order to
properly decode the stream to its original content.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
<code xmlns=""><i>encoding-type</i></code> will be a keyword
created by upcasing and interning the encoding type from
the header. <code xmlns=""><i>stream</i></code> will be the
stream that needs to be
decoded. <code xmlns=""><a href="#decode-stream">decode-stream</a></code> returns a new
stream from which you can read the decoded data.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*body-format-function*"></a>
[Special variable]
<br><b>*body-format-function*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
A function which determines whether the content body
returned by the server is text and should be treated as
such or not. The function is called after the request
<code xmlns=""><a href="#headers">headers</a></code> have been read and it must
accept two arguments, <code><i>headers</i></code> and
<code><i>external-format-in</i></code>, where
<code><i>headers</i></code> is like the third return value
of <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> while
<code><i>external-format-in</i></code> is the
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> argument of the same
name. It should return <code>NIL</code> if the body
should be regarded as binary content, or a <a href="http://weitz.de/flexi-streams/">FLEXI-STREAMS</a>
external format (which will be used to read the body)
otherwise.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
This function will only be called if the <a href="#arg-force-binary"><code><i>force-binary</i></code></a>
argument to <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> is
<code>NIL</code>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
The initial value of this variable is a function which
uses <code xmlns=""><a href="#*text-content-types*">*TEXT-CONTENT-TYPES*</a></code> to
determine whether the body is text and then proceeds as
described in the <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>
documentation entry.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*default-http-proxy*"></a>
[Special variable]
<br><b>*default-http-proxy*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
HTTP proxy to be used as default for the proxy keyword
argument of <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>. If not
<code>NIL</code>, it should be a string denoting a proxy
server through which the request should be sent. Or it
can be a list of two values - a string denoting the proxy
server and an integer denoting the port to use (which
will default to 80 otherwise).
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*no-proxy-domains*"></a>
[Special variable]
<br><b>*no-proxy-domains*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
A list of domains for which a proxy should not be used.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*drakma-default-external-format*"></a>
[Special variable]
<br><b>*drakma-default-external-format*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
The default value for the external format keyword
arguments of <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>. The value
of this variable will be interpreted by <a href="http://weitz.de/flexi-streams/">FLEXI-STREAMS</a>.
The initial value is the keyword <code>:LATIN-1</code>.
(Note that Drakma binds <a href="http://weitz.de/flexi-streams/#*default-eol-style*"><code>*DEFAULT-EOL-STYLE*</code></a>
to <code>:LF</code>).
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*header-stream*"></a>
[Special variable]
<br><b>*header-stream*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
If this variable is not <code>NIL</code>, it should be
bound to a stream to which incoming and outgoing headers
will be written for debugging purposes.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*text-content-types*"></a>
[Special variable]
<br><b>*text-content-types*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
A list of conses which are used by the default value of
<code xmlns=""><a href="#*body-format-function*">*BODY-FORMAT-FUNCTION*</a></code> to decide
whether a 'Content-Type' header denotes text content. The
car and cdr of each cons should each be a string or
<code>NIL</code>. A content type matches one of these
entries (and thus denotes text) if the type part is <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_stgeq_.htm"><code>STRING-EQUAL</code></a>
to the car or if the car is <code>NIL</code> and if the
subtype part is <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_stgeq_.htm"><code>STRING-EQUAL</code></a>
to the cdr or if the cdr is <code>NIL</code>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
The initial value of this variable is the list
<pre>(("text" . nil))</pre> which means that every content
type that starts with "text/" is regarded as text, no
matter what the subtype is.
</p>
</clix:description></blockquote></p>
<h4 xmlns=""><a name="headers">Headers</a></h4>
<p>
This section assembles a couple of convenience functions which
can be used to access information returned as the third value
(<code><i>headers</i></code>) of
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>.
</p>
<p>
Note that if the server sends <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2">multiple
headers with the same name</a>, these are comprised into one
entry by <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>. The values are
separated by commas.
</p>
<p xmlns=""><a class="none" name="get-content-type"></a>
[Function]
<br><b>get-content-type</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">headers</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">list</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Reads and parses a `Content-Type' header and returns it as
three values - the type, the subtype, and an alist
(possibly empty) of name/value pairs for the optional
parameters. <code xmlns=""><i>headers</i></code> is supposed to
be an alist of headers as returned by
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code>. Returns
<code>NIL</code> if there is no such header amongst
<code xmlns=""><i>headers</i></code>.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="header-value"></a>
[Function]
<br><b>header-value</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">name headers</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or string null)</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
If <code xmlns=""><i>headers</i></code> is an alist of headers as
returned by <code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> and
<code xmlns=""><i>name</i></code> is a keyword naming a header,
this function returns the corresponding value of this
header (or <code>NIL</code> if it's not in
<code xmlns=""><i>headers</i></code>).
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="read-tokens-and-parameters"></a>
[Function]
<br><b>read-tokens-and-parameters</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">string &key value-required-p</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">list</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Reads a comma-separated list of tokens from the string
<code xmlns=""><i>string</i></code>. Each token can be followed
by an optional, semicolon-separated list of
attribute/value pairs where the attributes are tokens
followed by a #\= character and a token or a quoted
string. Returned is a list where each element is either a
string (for a simple token) or a cons of a string (the
token) and an alist (the attribute/value pairs). If
<code xmlns=""><i>value-required-p</i></code> is <code>NIL</code>,
the value part (including the #\= character) of each
attribute/value pair is optional.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="split-tokens"></a>
[Function]
<br><b>split-tokens</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">string</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">list</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Splits the string <code xmlns=""><i>string</i></code> into a list
of substrings separated by commas and optional whitespace.
Empty substrings are ignored.
</p>
</clix:description></blockquote></p>
<h4 xmlns=""><a name="cookies">Cookies</a></h4>
<p>
<code xmlns=""><a href="#http-request">HTTP-REQUEST</a></code> can deal with <a href="http://en.wikipedia.org/wiki/HTTP_cookie">HTTP
cookies</a> if it gets a <a href="#cookie-jar">cookie jar</a>,
a collection of <code xmlns=""><a href="#cookie">COOKIE</a></code> objects, as its <a href="#arg-cookie-jar">cookie-jar</a> argument. Cookies sent
by the web server will be added to the cookie jar (or updated)
if appropriate and cookies already in the cookie jar will be
sent to the server together with the request.
</p>
<p>
Drakma will never remove cookies from a cookie jar
automatically. You have to do it manually using
<code xmlns=""><a href="#delete-old-cookies">DELETE-OLD-COOKIES</a></code>.
</p>
<p xmlns=""><a class="none" name="cookie"></a>
[Standard class]
<br><b>cookie</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Instances of this class represent <a href="http://en.wikipedia.org/wiki/HTTP_cookie">HTTP
cookies</a>. If you need to create your own cookies, you
should use <a href="http://www.lispworks.com/documentation/HyperSpec/Body/f_mk_ins.htm"><code>MAKE-INSTANCE</code></a>
with the initargs <code>:NAME</code>, <code>:DOMAIN</code>,
<code>:VALUE</code>, <code>:PATH</code>,
<code>:EXPIRES</code>, <code>:SECUREP</code>, and
<code>:HTTP-ONLY-P</code> all of which are optional except
for the first two. The meaning of these initargs and <a href="#cookie-name">the corresponding accessors</a> should
be pretty clear if one looks at the <a href="http://curl.haxx.se/rfc/cookie_spec.html">original
cookie specification</a> (and at <a href="http://msdn2.microsoft.com/en-us/library/ms533046.aspx">this
page</a> for the <code>HttpOnly</code> extension).
</p>
<pre xmlns="http://www.w3.org/1999/xhtml"><span class="repl-output">? </span><span class="repl-input">(make-instance 'drakma:cookie
:name "Foo"
:value "Bar"
:expires (+ (get-universal-time) 3600)
:domain ".weitz.de")</span>
<span class="repl-output">#<COOKIE Foo=Bar; expires=Sun, 09-12-2012 20:37:42 GMT; path=/; domain=.weitz.de></span>
</pre>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="parse-cookie-date"></a>
[Function]
<br><b>parse-cookie-date</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">string</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">universal-time</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Parses a cookie expiry date and returns it as a Lisp <a href="http://www.lispworks.com/documentation/HyperSpec/Body/25_adb.htm">universal
time</a>. Currently understands the following formats:
</p>
<pre xmlns="http://www.w3.org/1999/xhtml">"Wed, 06-Feb-2008 21:01:38 GMT"
"Wed, 06-Feb-08 21:01:38 GMT"
"Tue Feb 13 08:00:00 2007 GMT"
"Wednesday, 07-February-2027 08:55:23 GMT"
"Wed, 07-02-2017 10:34:45 GMT"</pre>
<p xmlns="http://www.w3.org/1999/xhtml">
Instead of "GMT" time zone abbreviations like "CEST" and UTC
offsets like "GMT-01:30" are also allowed.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
While this function has "cookie" in its name, it might
come in handy in other situations as well and it is thus
exported as a convenience function.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="cookie="></a>
[Function]
<br><b>cookie=</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie1 cookie2</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">boolean</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
Returns a true value if the cookies
<code><i>cookie1</i></code> and
<code><i>cookie2</i></code> are equal. Two cookies are
considered to be equal if name and path are equal.
</clix:description></blockquote></p>
<p xmlns="">
[Generic accessors]<br><a class="none" name="cookie-name"></a><b>cookie-name</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">string</clix:returns></i><br><tt>(setf (</tt><b>cookie-name</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-value"></a><b>cookie-value</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or string null)</clix:returns></i><br><tt>(setf (</tt><b>cookie-value</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-domain"></a><b>cookie-domain</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">string</clix:returns></i><br><tt>(setf (</tt><b>cookie-domain</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-path"></a><b>cookie-path</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or string null)</clix:returns></i><br><tt>(setf (</tt><b>cookie-path</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-expires"></a><b>cookie-expires</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or integer null)</clix:returns></i><br><tt>(setf (</tt><b>cookie-expires</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-http-only-p"></a><b>cookie-http-only-p</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">boolean</clix:returns></i><br><tt>(setf (</tt><b>cookie-http-only-p</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><a class="none" name="cookie-securep"></a><b>cookie-securep</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">boolean</clix:returns></i><br><tt>(setf (</tt><b>cookie-securep</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><blockquote></blockquote></p>
<p xmlns=""><a class="none" name="cookie-jar"></a>
[Standard class]
<br><b>cookie-jar</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
An object of this class encapsulates a collection (a list,
actually) of <code>COOKIE</code> objects. You create a new
cookie jar with <code>(MAKE-INSTANCE 'COOKIE-JAR)</code>
where you can optionally provide a list of
<code xmlns=""><a href="#cookie">COOKIE</a></code> objects with the
<code>:COOKIES</code> initarg. The cookies in a cookie jar
are accessed with <code xmlns=""><a href="#cookie-jar-cookies">COOKIE-JAR-COOKIES</a></code>.
</p>
</clix:description></blockquote></p>
<p xmlns="">
[Generic accessors]<br><a class="none" name="cookie-jar-cookies"></a><b>cookie-jar-cookies</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie-jar</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">list</clix:returns></i><br><tt>(setf (</tt><b>cookie-jar-cookies</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie-jar</clix:lambda-list></i><tt>) <i>new-value</i>)</tt><br><blockquote></blockquote></p>
<p xmlns=""><a class="none" name="delete-old-cookies"></a>
[Function]
<br><b>delete-old-cookies</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie-jar</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">cookie-jar</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Removes all cookies from <code xmlns=""><i>cookie-jar</i></code>
which have either expired or which don't have an expiry
date.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*allow-dotless-cookie-domains-p*"></a>
[Special variable]
<br><b>*allow-dotless-cookie-domains-p*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
When this variable is not <code>NIL</code>, cookie domains
containing no dots are considered valid. The default is
<code>NIL</code>, meaning to disallow such domains except
for "localhost".
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*ignore-unparseable-cookie-dates-p*"></a>
[Special variable]
<br><b>*ignore-unparseable-cookie-dates-p*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Whether Drakma is allowed to treat `Expires' dates in
cookie headers as non-existent if it can't parse them. If
the value of this variable is <code>NIL</code> (which is
the default), an error will be signalled instead.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="*remove-duplicate-cookies-p*"></a>
[Special variable]
<br><b>*remove-duplicate-cookies-p*</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Determines how duplicate cookies in the response are
handled, defaults to <code>T</code>. Cookies are
considered duplicate using <a href="#cookie="><code>COOKIE=</code></a>.
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
Valid values are:
<ul>
<li><code>NIL</code> - duplicates will not be
removed,</li>
<li><code>T</code> or <code>:KEEP-LAST</code> - for
duplicates, only the last cookie value will be kept,
based on the order of the response header,</li>
<li><code>:KEEP-FIRST</code> - for duplicates, only the
first cookie value will be kept, based on the order of
the response header.</li>
</ul>
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
Misbehaving servers may send duplicate cookies back in the
same <code>Set-Cookie</code> header:
</p>
<pre xmlns="http://www.w3.org/1999/xhtml">HTTP/1.1 200 OK
Server: My-hand-rolled-server
Date: Wed, 07 Apr 2010 15:12:30 GMT
Connection: Close
Content-Type: text/html
Content-Length: 82
Set-Cookie: a=1; Path=/; Secure, a=2; Path=/; Secure
</pre>
<p xmlns="http://www.w3.org/1999/xhtml">
In this case Drakma has to choose whether cookie "a" has
the value "1" or "2". By default, Drakma will choose the
last value specified, in this case "2".
</p>
<p xmlns="http://www.w3.org/1999/xhtml">
By default, Drakma conforms to <a href="http://www.w3.org/Protocols/rfc2109/rfc2109">RFC2109
HTTP State Management Mechanism</a>, section 4.3.3 Cookie
Management:
<blockquote>
<em>
If a user agent receives a Set-Cookie response header
whose NAME is the same as a pre-existing cookie, and
whose Domain and Path attribute values exactly
(string) match those of a pre-existing cookie, the new
cookie supersedes the old.
</em>
</blockquote>
</p>
</clix:description></blockquote></p>
<h4 xmlns=""><a name="conditions">Conditions</a></h4>
<p>
This section lists all the condition types that are defined by
Drakma.
</p>
<p xmlns=""><a class="none" name="cookie-date-parse-error"></a>
[Condition type]
<br><b>cookie-date-parse-error</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Signalled if Drakma tries to parse the date of an incoming
cookie header and can't interpret it.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="cookie-error"></a>
[Condition type]
<br><b>cookie-error</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Signalled if someone tries to create a COOKIE object
that's not valid.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="cookie-error-cookie"></a>
[Generic function]
<br><b>cookie-error-cookie</b> <i><clix:lambda-list xmlns:clix="http://bknr.net/clixdoc">cookie-error</clix:lambda-list></i>
=>
<i><clix:returns xmlns:clix="http://bknr.net/clixdoc">(or cookie null)</clix:returns></i><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
The <code>COOKIE</code> object that caused this error.
Can be <code>NIL</code> in case such an object couldn't be
initialized.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="parameter-error"></a>
[Condition type]
<br><b>parameter-error</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Signalled if a function was called with inconsistent or
illegal parameters.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="syntax-error"></a>
[Condition type]
<br><b>syntax-error</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Signalled if Drakma encounters wrong or unknown syntax
when reading the reply from the server.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="drakma-condition"></a>
[Condition type]
<br><b>drakma-condition</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Superclass for all conditions related to Drakma.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="drakma-error"></a>
[Condition type]
<br><b>drakma-error</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Superclass for all errors related to Drakma.
</p>
</clix:description></blockquote></p>
<p xmlns=""><a class="none" name="drakma-warning"></a>
[Condition type]
<br><b>drakma-warning</b><blockquote><clix:description xmlns:clix="http://bknr.net/clixdoc">
<p xmlns="http://www.w3.org/1999/xhtml">
Superclass for all warnings related to Drakma.
</p>
</clix:description></blockquote></p>
<h3 xmlns=""><a class="none" name="index">Symbol index</a></h3>
<ul xmlns="">
<li>
<code><a href="#*allow-dotless-cookie-domains-p*">*allow-dotless-cookie-domains-p*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*body-format-function*">*body-format-function*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*default-http-proxy*">*default-http-proxy*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*drakma-default-external-format*">*drakma-default-external-format*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*header-stream*">*header-stream*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*ignore-unparseable-cookie-dates-p*">*ignore-unparseable-cookie-dates-p*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*no-proxy-domains*">*no-proxy-domains*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*remove-duplicate-cookies-p*">*remove-duplicate-cookies-p*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#*text-content-types*">*text-content-types*</a></code><span class="entry-type">Special variable</span>
</li>
<li>
<code><a href="#cookie">cookie</a></code><span class="entry-type">Standard class</span>
</li>
<li>
<code><a href="#cookie-date-parse-error">cookie-date-parse-error</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#cookie-domain">cookie-domain</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-error">cookie-error</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#cookie-error-cookie">cookie-error-cookie</a></code><span class="entry-type">Generic function</span>
</li>
<li>
<code><a href="#cookie-expires">cookie-expires</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-http-only-p">cookie-http-only-p</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-jar">cookie-jar</a></code><span class="entry-type">Standard class</span>
</li>
<li>
<code><a href="#cookie-jar-cookies">cookie-jar-cookies</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-name">cookie-name</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-path">cookie-path</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-securep">cookie-securep</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie-value">cookie-value</a></code><span class="entry-type">Generic accessor</span>
</li>
<li>
<code><a href="#cookie=">cookie=</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#decode-stream">decode-stream</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#delete-old-cookies">delete-old-cookies</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#drakma-condition">drakma-condition</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#drakma-error">drakma-error</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#drakma-warning">drakma-warning</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#get-content-type">get-content-type</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#header-value">header-value</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#http-request">http-request</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#parameter-error">parameter-error</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#parameter-present-p">parameter-present-p</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#parameter-value">parameter-value</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#parse-cookie-date">parse-cookie-date</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#read-tokens-and-parameters">read-tokens-and-parameters</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#split-tokens">split-tokens</a></code><span class="entry-type">Function</span>
</li>
<li>
<code><a href="#syntax-error">syntax-error</a></code><span class="entry-type">Condition type</span>
</li>
<li>
<code><a href="#url-encode">url-encode</a></code><span class="entry-type">Function</span>
</li>
</ul>
</body></html>
| 94,807 | Common Lisp | .l | 1,698 | 47.882214 | 416 | 0.635127 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | c09d6881b5b40e72dc0ce77b67f8426f792692e7ec9bae00fabd601e108b123f | 43,234 | [
-1
] |
43,237 | .travis.yml | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/trivial-garbage-20211230-git/.travis.yml | language: lisp
env:
matrix:
- LISP=abcl
- LISP=allegro
- LISP=sbcl
- LISP=sbcl32
- LISP=ccl
- LISP=ccl32
- LISP=clisp
- LISP=clisp32
# - LISP=cmucl
- LISP=ecl
# matrix:
# allow_failures:
# - env: LISP=ecl
install:
- curl -L https://github.com/luismbo/cl-travis/raw/master/install.sh | sh
script:
- cl -e '(ql:quickload :trivial-garbage/tests)
(unless (trivial-garbage-tests:run)
(uiop:quit 1))'
| 475 | Common Lisp | .l | 22 | 17.227273 | 75 | 0.614699 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 9ab061f9cf1ba61ec62cc045729712ee8bc3de3bc2215550ec537a7641baea4f | 43,237 | [
-1
] |
43,241 | .gitlab-ci.yml | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/alexandria-20220707-git/.gitlab-ci.yml | include:
project: 'clci/gitlab-ci'
ref: release/v2-dev
file:
- definitions.gitlab-ci.yml
- test-pipeline.gitlab-ci.yml
variables:
CLCI_INSTALL_QUICKLISP_CLIENT: "yes"
# Off by default because it's proprietary and has a separate license.
CLCI_TEST_ALLEGRO: "yes"
# Off by default because the Docker image is a bit out of date, due to
# upstream churn.
CLCI_TEST_CLASP: "yes"
# Alexandria is a non-commercial project, so we can use the express version
# of Allegro for testing.
I_AGREE_TO_ALLEGRO_EXPRESS_LICENSE: "yes"
# This section is not strictly required, but prevents Gitlab CI from launching
# multiple redundent pipelines when a Merge Request is opened.
workflow:
rules:
- if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
- if: '$CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS'
when: never
- if: '$CI_COMMIT_BRANCH'
- if: '$CI_COMMIT_TAG'
| 902 | Common Lisp | .l | 25 | 32.76 | 78 | 0.72 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 5cff50f438b9ca80590b2e7fca38bded40d8759e21ac4ea55a7573c7b832ad3d | 43,241 | [
-1
] |
43,261 | Makefile | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/alexandria-20220707-git/doc/Makefile | .PHONY: clean html pdf include clean-include clean-crap info doc
doc: pdf html info clean-crap
clean-include:
rm -rf include
clean-crap:
rm -f *.aux *.cp *.fn *.fns *.ky *.log *.pg *.toc *.tp *.tps *.vr
clean: clean-include
rm -f *.pdf *.html *.info
include:
sbcl --no-userinit --eval '(require :asdf)' \
--eval '(let ((asdf:*central-registry* (list "../"))) (require :alexandria))' \
--eval '(with-compilation-unit () (load "docstrings.lisp"))' \
--eval '(sb-texinfo:generate-includes "include/" (list :alexandria-1 :alexandria-2) :base-package :alexandria)' \
--eval '(quit)'
pdf: include
texi2pdf alexandria.texinfo
html: include
makeinfo --html --no-split alexandria.texinfo
info: include
makeinfo alexandria.texinfo
publish:
rsync -va alexandria.pdf alexandria.html common-lisp.net:/project/alexandria/public_html/draft/
| 848 | Common Lisp | .l | 22 | 36.590909 | 114 | 0.718482 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | dcf05df5d79fd27d2ad5ee6018d85ec7b565ae2f9ac55d29243c100014dd50a6 | 43,261 | [
-1
] |
43,262 | alexandria.texinfo | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/alexandria-20220707-git/doc/alexandria.texinfo | \input texinfo @c -*-texinfo-*-
@c %**start of header
@setfilename alexandria.info
@settitle alexandria Manual
@c %**end of header
@settitle alexandria Manual -- draft version
@c for install-info
@dircategory Software development
@direntry
* alexandria: Common Lisp utilities.
@end direntry
@copying
Alexandria software and associated documentation are in the public
domain:
@quotation
Authors dedicate this work to public domain, for the benefit of the
public at large and to the detriment of the authors' heirs and
successors. Authors intends this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights under
copyright law, whether vested or contingent, in the work. Authors
understands that such relinquishment of all rights includes the
relinquishment of all rights to enforce (by lawsuit or otherwise)
those copyrights in the work.
Authors recognize that, once placed in the public domain, the work
may be freely reproduced, distributed, transmitted, used, modified,
built upon, or otherwise exploited by anyone for any purpose,
commercial or non-commercial, and in any way, including by methods
that have not yet been invented or conceived.
@end quotation
In those legislations where public domain dedications are not
recognized or possible, Alexandria is distributed under the following
terms and conditions:
@quotation
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation files
(the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@end quotation
Unless otherwise noted, the symbols are exported from
the @code{"ALEXANDRIA"} package; only newer symbols
that require @code{"ALEXANDRIA-2"} are fully qualified.
The package @code{"ALEXANDRIA-2"} includes all the symbols
from @code{"ALEXANDRIA-1"}.
@end copying
@titlepage
@title alexandria Manual
@subtitle draft version
@c The following two commands start the copyright page.
@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage
@contents
@ifnottex
@include include/ifnottex.texinfo
@node Top
@comment node-name, next, previous, up
@top Alexandria
@insertcopying
@menu
* Hash Tables::
* Data and Control Flow::
* Conses::
* Sequences::
* IO::
* Macro Writing::
* Symbols::
* Arrays::
* Types::
* Numbers::
@end menu
@end ifnottex
@node Hash Tables
@comment node-name, next, previous, up
@chapter Hash Tables
@include include/macro-alexandria-ensure-gethash.texinfo
@include include/fun-alexandria-copy-hash-table.texinfo
@include include/fun-alexandria-maphash-keys.texinfo
@include include/fun-alexandria-maphash-values.texinfo
@include include/fun-alexandria-hash-table-keys.texinfo
@include include/fun-alexandria-hash-table-values.texinfo
@include include/fun-alexandria-hash-table-alist.texinfo
@include include/fun-alexandria-hash-table-plist.texinfo
@include include/fun-alexandria-alist-hash-table.texinfo
@include include/fun-alexandria-plist-hash-table.texinfo
@node Data and Control Flow
@comment node-name, next, previous, up
@chapter Data and Control Flow
@include include/macro-alexandria-define-constant.texinfo
@include include/macro-alexandria-destructuring-case.texinfo
@include include/macro-alexandria-ensure-functionf.texinfo
@include include/macro-alexandria-multiple-value-prog2.texinfo
@include include/macro-alexandria-named-lambda.texinfo
@include include/macro-alexandria-nth-value-or.texinfo
@include include/macro-alexandria-if-let.texinfo
@include include/macro-alexandria-when-let.texinfo
@include include/macro-alexandria-when-let-star.texinfo
@include include/macro-alexandria-switch.texinfo
@include include/macro-alexandria-cswitch.texinfo
@include include/macro-alexandria-eswitch.texinfo
@include include/macro-alexandria-whichever.texinfo
@include include/macro-alexandria-xor.texinfo
@include include/fun-alexandria-disjoin.texinfo
@include include/fun-alexandria-conjoin.texinfo
@include include/fun-alexandria-compose.texinfo
@include include/fun-alexandria-ensure-function.texinfo
@include include/fun-alexandria-multiple-value-compose.texinfo
@include include/fun-alexandria-curry.texinfo
@include include/fun-alexandria-rcurry.texinfo
@include include/macro-alexandria-2-line-up-first.texinfo
@include include/macro-alexandria-2-line-up-last.texinfo
@node Conses
@comment node-name, next, previous, up
@chapter Conses
@include include/type-alexandria-proper-list.texinfo
@include include/type-alexandria-circular-list.texinfo
@include include/macro-alexandria-appendf.texinfo
@include include/macro-alexandria-nconcf.texinfo
@include include/macro-alexandria-remove-from-plistf.texinfo
@include include/macro-alexandria-delete-from-plistf.texinfo
@include include/macro-alexandria-reversef.texinfo
@include include/macro-alexandria-nreversef.texinfo
@include include/macro-alexandria-unionf.texinfo
@include include/macro-alexandria-nunionf.texinfo
@include include/macro-alexandria-doplist.texinfo
@include include/fun-alexandria-circular-list-p.texinfo
@include include/fun-alexandria-circular-tree-p.texinfo
@include include/fun-alexandria-proper-list-p.texinfo
@include include/fun-alexandria-alist-plist.texinfo
@include include/fun-alexandria-plist-alist.texinfo
@include include/fun-alexandria-circular-list.texinfo
@include include/fun-alexandria-make-circular-list.texinfo
@include include/fun-alexandria-ensure-car.texinfo
@include include/fun-alexandria-ensure-cons.texinfo
@include include/fun-alexandria-ensure-list.texinfo
@include include/fun-alexandria-flatten.texinfo
@include include/fun-alexandria-lastcar.texinfo
@include include/fun-alexandria-setf-lastcar.texinfo
@include include/fun-alexandria-proper-list-length.texinfo
@include include/fun-alexandria-mappend.texinfo
@include include/fun-alexandria-map-product.texinfo
@include include/fun-alexandria-remove-from-plist.texinfo
@include include/fun-alexandria-delete-from-plist.texinfo
@include include/fun-alexandria-2-delete-from-plist-star.texinfo
@include include/fun-alexandria-set-equal.texinfo
@include include/fun-alexandria-setp.texinfo
@node Sequences
@comment node-name, next, previous, up
@chapter Sequences
@include include/type-alexandria-proper-sequence.texinfo
@include include/macro-alexandria-deletef.texinfo
@include include/macro-alexandria-removef.texinfo
@include include/fun-alexandria-rotate.texinfo
@include include/fun-alexandria-shuffle.texinfo
@include include/fun-alexandria-random-elt.texinfo
@include include/fun-alexandria-emptyp.texinfo
@include include/fun-alexandria-sequence-of-length-p.texinfo
@include include/fun-alexandria-length-equals.texinfo
@include include/fun-alexandria-copy-sequence.texinfo
@include include/fun-alexandria-first-elt.texinfo
@include include/fun-alexandria-setf-first-elt.texinfo
@include include/fun-alexandria-last-elt.texinfo
@include include/fun-alexandria-setf-last-elt.texinfo
@include include/fun-alexandria-starts-with.texinfo
@include include/fun-alexandria-starts-with-subseq.texinfo
@include include/fun-alexandria-ends-with.texinfo
@include include/fun-alexandria-ends-with-subseq.texinfo
@include include/fun-alexandria-map-combinations.texinfo
@include include/fun-alexandria-map-derangements.texinfo
@include include/fun-alexandria-map-permutations.texinfo
@node IO
@comment node-name, next, previous, up
@chapter IO
@include include/fun-alexandria-read-stream-content-into-string.texinfo
@include include/fun-alexandria-read-file-into-string.texinfo
@include include/fun-alexandria-read-stream-content-into-byte-vector.texinfo
@include include/fun-alexandria-read-file-into-byte-vector.texinfo
@node Macro Writing
@comment node-name, next, previous, up
@chapter Macro Writing
@include include/macro-alexandria-once-only.texinfo
@include include/macro-alexandria-with-gensyms.texinfo
@include include/macro-alexandria-with-unique-names.texinfo
@include include/fun-alexandria-featurep.texinfo
@include include/fun-alexandria-parse-body.texinfo
@include include/fun-alexandria-parse-ordinary-lambda-list.texinfo
@node Symbols
@comment node-name, next, previous, up
@chapter Symbols
@include include/fun-alexandria-ensure-symbol.texinfo
@include include/fun-alexandria-format-symbol.texinfo
@include include/fun-alexandria-make-keyword.texinfo
@include include/fun-alexandria-make-gensym.texinfo
@include include/fun-alexandria-make-gensym-list.texinfo
@include include/fun-alexandria-symbolicate.texinfo
@node Arrays
@comment node-name, next, previous, up
@chapter Arrays
@include include/type-alexandria-array-index.texinfo
@include include/type-alexandria-array-length.texinfo
@include include/fun-alexandria-copy-array.texinfo
@node Types
@comment node-name, next, previous, up
@chapter Types
@include include/type-alexandria-string-designator.texinfo
@include include/macro-alexandria-coercef.texinfo
@include include/fun-alexandria-of-type.texinfo
@include include/fun-alexandria-type-equals.texinfo
@node Numbers
@comment node-name, next, previous, up
@chapter Numbers
@include include/macro-alexandria-maxf.texinfo
@include include/macro-alexandria-minf.texinfo
@include include/fun-alexandria-binomial-coefficient.texinfo
@include include/fun-alexandria-count-permutations.texinfo
@include include/fun-alexandria-clamp.texinfo
@include include/fun-alexandria-lerp.texinfo
@include include/fun-alexandria-factorial.texinfo
@include include/fun-alexandria-subfactorial.texinfo
@include include/fun-alexandria-gaussian-random.texinfo
@include include/fun-alexandria-iota.texinfo
@include include/fun-alexandria-map-iota.texinfo
@include include/fun-alexandria-mean.texinfo
@include include/fun-alexandria-median.texinfo
@include include/fun-alexandria-variance.texinfo
@include include/fun-alexandria-standard-deviation.texinfo
@bye
| 10,583 | Common Lisp | .l | 237 | 43.202532 | 76 | 0.838077 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | fcc25d0fd43e9790f8f2d7027e27e512863c0614312570470f6731b047cf3c78 | 43,262 | [
-1
] |
43,275 | changelog | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-base64-20201016-git/debian/changelog | cl-base64 (3.4.0-1) unstable; urgency=medium
* New upstream.
Performance and safety improvements (thanks to Janis Dzerins)
-- Kevin M. Rosenberg <kmr@debian.org> Wed, 30 Sep 2020 18:06:36 +0000
cl-base64 (3.3.4-1) unstable; urgency=medium
* New upstream. (closes:796978) Thanks to Denis Martinez.
* Switch to dpkg-source 3.0 (quilt) format
-- Kevin M. Rosenberg <kmr@debian.org> Sun, 30 Aug 2015 21:02:49 -0600
cl-base64 (3.3.3-2) unstable; urgency=low
* Convert installation to dh-lisp
* control: Add Vcs-Browser field
-- Kevin M. Rosenberg <kmr@debian.org> Mon, 03 Aug 2009 10:31:33 -0600
cl-base64 (3.3.3-1) unstable; urgency=low
* New upstream
* Convert to debhelper version 7
* debian/watch: New file
* debian/control: Change section to new lisp section. Add Vcs-Git
and Homepage fields.
* debian/rules: Change to just architecture independent rules and DH7
* debian/{prerm,postinst}: Remove paths from binary function
-- Kevin M. Rosenberg <kmr@debian.org> Sat, 01 Aug 2009 23:19:43 -0600
cl-base64 (3.3.2-1) unstable; urgency=low
* Depend on kmrcl only for test package
-- Kevin M. Rosenberg <kmr@debian.org> Sun, 27 Aug 2006 12:23:37 -0600
cl-base64 (3.3.1-5) unstable; urgency=low
* Fix spelling mistake in package description (closes:363204)
-- Kevin M. Rosenberg <kmr@debian.org> Mon, 15 May 2006 17:41:36 -0600
cl-base64 (3.3.1-4) unstable; urgency=low
* New upstream URI
-- Kevin M. Rosenberg <kmr@debian.org> Sat, 17 Sep 2005 15:34:55 -0600
cl-base64 (3.3.1-3) unstable; urgency=low
* Fix package name in postinst/prerm
-- Kevin M. Rosenberg <kmr@debian.org> Thu, 22 Apr 2004 08:53:34 -0600
cl-base64 (3.3.1-2) unstable; urgency=low
* Rename package rules file (closes:244687)
-- Kevin M. Rosenberg <kmr@debian.org> Mon, 19 Apr 2004 08:59:58 -0600
cl-base64 (3.3.1-1) unstable; urgency=low
* Rename ASDF system to cl-base64
-- Kevin M. Rosenberg <kmr@debian.org> Sun, 18 Apr 2004 10:39:51 -0600
cl-base64 (3.3-1) unstable; urgency=low
* Rework test loading
-- Kevin M. Rosenberg <kmr@debian.org> Sun, 24 Aug 2003 13:40:03 -0600
cl-base64 (3.2.1-1) unstable; urgency=low
* New upstream
-- Kevin M. Rosenberg <kmr@debian.org> Thu, 12 Jun 2003 08:04:55 -0600
cl-base64 (3.2-1) unstable; urgency=low
* Improve .asd file
-- Kevin M. Rosenberg <kmr@debian.org> Tue, 6 May 2003 10:19:22 -0600
cl-base64 (3.1-1) unstable; urgency=low
* Implement asdf:test-op. Remove old base64-test.asd file.
-- Kevin M. Rosenberg <kmr@debian.org> Tue, 15 Apr 2003 09:33:01 -0600
cl-base64 (3.0.2-1) unstable; urgency=low
* Change declarations from array to simple-array where feasible
* add more fixnum declarations where helpful
-- Kevin M. Rosenberg <kmr@debian.org> Tue, 14 Jan 2003 04:55:48 -0700
cl-base64 (3.0.1-1) unstable; urgency=low
* Fix output of base64-string-to-usb8-array
-- Kevin M. Rosenberg <kmr@debian.org> Tue, 14 Jan 2003 04:35:05 -0700
cl-base64 (3.0.0-1) unstable; urgency=low
* Remove src.lisp and add package.lisp, decode.lisp, encode.lisp
* Add support for usb8-arrays
* Rewrite routines as macros to create efficient functions for
converting to and from streams, strings, and usb8-arrays.
* Fix error in integer-to-base64 when using columns
* Add base64-test.asd and test.lisp regression suite
-- Kevin M. Rosenberg <kmr@debian.org> Mon, 13 Jan 2003 14:41:52 -0700
cl-base64 (2.1.0-1) unstable; urgency=low
* Fix broken string-to-base64
-- Kevin M. Rosenberg <kmr@debian.org> Sat, 4 Jan 2003 06:40:32 -0700
cl-base64 (2.0-1) unstable; urgency=low
* Ignore whitespace in base64 strings
* Add column breaking and stream output to base64 conversion
* Rework string-to-base64 to handle columns and streams
-- Kevin M. Rosenberg <kmr@debian.org> Fri, 3 Jan 2003 23:14:13 -0700
cl-base64 (1.2-1) unstable; urgency=low
* Bug fix in base64-to-integer
-- Kevin M. Rosenberg <kmr@debian.org> Sun, 29 Dec 2002 00:03:11 -0700
cl-base64 (1.1-1) unstable; urgency=low
* Rewritten version, significant optimizations
* BSD-style license
* Adds conversion to and from integers
* Renamed functions
-- Kevin M. Rosenberg <kmr@debian.org> Sat, 28 Dec 2002 21:28:42 -0700
cl-base64 (1.0-1) unstable; urgency=low
* Initial upload
* Changes compared to upstream:
- Added .asd file for use with Common Lisp Controller
- Changes for Allegro's case sensitive mode
-- Kevin M. Rosenberg <kmr@debian.org> Thu, 26 Dec 2002 19:17:51 -0700
| 4,544 | Common Lisp | .l | 89 | 47.898876 | 72 | 0.726817 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 577e413fb9a0219445c177e5755865b86a3c16c26631d0c66c94ed546c1fe921 | 43,275 | [
-1
] |
43,276 | rules | NailykSturm_Info805-TP/src/Import/quicklisp/dists/quicklisp/software/cl-base64-20201016-git/debian/rules | #!/usr/bin/make -f
pkg := cl-base64
debpkg := cl-base64
clc-source := usr/share/common-lisp/source
clc-systems := usr/share/common-lisp/systems
clc-files := $(clc-source)/$(pkg)
doc-dir := usr/share/doc/$(debpkg)
build: build-indep build-arch
build-indep:
build-arch:
clean:
dh_testdir
dh_testroot
dh_clean
install: build
dh_testdir
dh_testroot
dh_prep
dh_installdirs
dh_install $(pkg).asd $(clc-files)
dh_install *.lisp $(clc-files)
binary-indep: install
dh_testdir
dh_testroot
dh_installchangelogs
dh_installdocs
dh_lisp
dh_compress
dh_fixperms
dh_installdeb
dh_gencontrol
dh_md5sums
dh_builddeb
binary-arch:
binary: binary-indep
.PHONY: build clean binary-indep binary-arch binary install
| 728 | Common Lisp | .l | 36 | 18.333333 | 59 | 0.777941 | NailykSturm/Info805-TP | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:51:23 AM (Europe/Amsterdam) | 837fbfec2400cb7f768a522c17e9dbc1fa32a2fd0f22cdb52307b2c4682aefaf | 43,276 | [
-1
] |