mirrors/nixpkgs
1
0
Fork 1
mirror of https://github.com/NixOS/nixpkgs.git synced 2024-11-18 03:30:45 +00:00
Code Issues Wiki Activity

Merge pull request #309696 from Uthar/lisp-removal-of-previous-variants

Browse source 
Lisp modules - removal of previous variants
This commit is contained in:
7c6f434c 2024-05-08 10:04:39 +00:00 committed by GitHub
parent 11cd4b2ef4 fc5b715e1a
commit 55e9b296c1
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
466 changed files with 35 additions and 96488 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
nixos/doc/manual/release-notes/rl-2405.section.md
View file

@ -683,6 +683,8 @@ The pre-existing [services.ankisyncd](#opt-services.ankisyncd.enable) has been m
making it possible to accumulate definitions without resorting to `mkForce`,
hence to retain the definitions not anticipating that need.
- Lisp modules: previously deprecated interface based on `common-lisp.sh` has now been removed.
- `youtrack` is bumped to 2023.3. The update is not performed automatically, it requires manual interaction. See the YouTrack section in the manual for details.
- QtMultimedia has changed its default backend to `QT_MEDIA_BACKEND=ffmpeg` (previously `gstreamer` on Linux or `darwin` on MacOS).

2
nixos/modules/services/x11/window-managers/clfswm.nix
View file

@ -10,7 +10,7 @@ in
options = {
services.xserver.windowManager.clfswm = {
enable = mkEnableOption "clfswm";
package = mkPackageOption pkgs [ "lispPackages" "clfswm" ] { };
package = mkPackageOption pkgs [ "sbclPackages" "clfswm" ] { };
};
};

4
pkgs/development/libraries/libuv/default.nix
View file

@ -11,7 +11,7 @@
, bind
, cmake
, knot-resolver
, lispPackages
, sbclPackages
, luajitPackages
, mosquitto
, neovim
@ -105,7 +105,7 @@ stdenv.mkDerivation (finalAttrs: {
passthru.tests = {
inherit bind cmake knot-resolver mosquitto neovim nodejs;
inherit (lispPackages) cl-libuv;
inherit (sbclPackages) cl-libuv;
luajit-libluv = luajitPackages.libluv;
luajit-luv = luajitPackages.luv;
ocaml-luv = ocamlPackages.luv;

1
pkgs/development/lisp-modules-new-obsolete/.gitattributes vendored
View file

@ -1 +0,0 @@
imported.nix linguist-vendored

3
pkgs/development/lisp-modules-new-obsolete/.gitignore vendored
View file

@ -1,3 +0,0 @@
result
*.sqlite
*.fasl

197
pkgs/development/lisp-modules-new-obsolete/doc/api.md
View file

@ -1,197 +0,0 @@
## The API
This page documents the Nix API of nix-cl.
## Overview
The core API functions are `build-asdf-system` and
`lispWithPackagesInternal`.
They are considered more low-level that the rest of the API, which
builds on top of them to provide a more convenient interface with sane
defaults.
The higher-level API provides a lot of pre-configured packages,
including all of Quicklisp, and consists of the functions:
- `lispPackagesFor`
- `lispWithPackages`
Finally, there are functions that provide pre-defined Lisps, for
people who don't need to customize that:
- `abclPackages`, `eclPackages`, `cclPackages`, `claspPackages`, `sbclPackages`
- `abclWithPackages`, `eclWithPackages`, `cclWithPackages`, `claspWithPackages`, `sbclWithPackages`
The following is an attempt to document all of this.
## Packaging systems - `build-asdf-system`
Packages are declared using `build-asdf-system`. This function takes
the following arguments and returns a `derivation`.
#### Required arguments
##### `pname`
Name of the package/library
##### `version`
Version of the package/library
##### `src`
Source of the package/library (`fetchzip`, `fetchgit`, `fetchhg` etc.)
##### `lisp`
This command must load the provided file (`$buildScript`) then exit
immediately. For example, SBCL's --script flag does just that.
#### Optional arguments
##### `patches ? []`
Patches to apply to the source code before compiling it. This is a
list of files.
##### `nativeLibs ? []`
Native libraries, will be appended to the library
path. (`pkgs.openssl` etc.)
##### `javaLibs ? []`
Java libraries for ABCL, will be appended to the class path.
##### `lispLibs ? []`
Lisp dependencies These must themselves be packages built with
`build-asdf-system`
##### `systems ? [ pname ]`
Some libraries have multiple systems under one project, for example,
[cffi] has `cffi-grovel`, `cffi-toolchain` etc. By default, only the
`pname` system is build.
`.asd's` not listed in `systems` are removed before saving the library
to the Nix store. This prevents ASDF from referring to uncompiled
systems on run time.
Also useful when the `pname` is different than the system name, such
as when using [reverse domain naming]. (see `jzon` ->
`com.inuoe.jzon`)
[cffi]: https://cffi.common-lisp.dev/
[reverse domain naming]: https://en.wikipedia.org/wiki/Reverse_domain_name_notation
##### `asds ? systems`
The .asd files that this package provides. By default, same as
`systems`.
#### Return value
A `derivation` that, when built, contains the sources and pre-compiled
FASL files (Lisp implementation dependent) alongside any other
artifacts generated during compilation.
#### Example
[bordeaux-threads.nix] contains a simple example of packaging
`alexandria` and `bordeaux-threads`.
[bordeaux-threads.nix]: /examples/bordeaux-threads.nix
## Building a Lisp with packages: `lispWithPackagesInternal`
Generators of Lisps configured to be able to `asdf:load-system`
pre-compiled libraries on run-time are built with
`lispWithPackagesInternal`.
#### Required Arguments
##### `clpkgs`
An attribute set of `derivation`s returned by `build-asdf-system`
#### Return value
`lispWithPackagesInternal` returns a function that takes one argument:
a function `(lambda (clpkgs) packages)`, that, given a set of
packages, returns a list of package `derivation`s to be included in
the closure.
#### Example
The [sbcl-with-bt.nix] example creates a runnable Lisp where the
`bordeaux-threads` defined in the previous section is precompiled and
loadable via `asdf:load-system`:
[sbcl-with-bt.nix]: /examples/sbcl-with-bt.nix
## Reusing pre-packaged Lisp libraries: `lispPackagesFor`
`lispPackagesFor` is a higher level version of
`lispPackagesForInternal`: it only takes one argument - a Lisp command
to use for compiling packages. It then provides a bunch of ready to
use packages.
#### Required Arguments
##### `lisp`
The Lisp command to use in calls to `build-asdf-system` while building
the library-provided Lisp package declarations.
#### Return value
A set of packages built with `build-asdf-system`.
#### Example
The [abcl-package-set.nix] example generates a set of thousands of packages for ABCL.
[abcl-package-set.nix]: /examples/abcl-package-set.nix
## Reusing pre-packaged Lisp libraries, part 2: `lispWithPackages`
This is simply a helper function to avoid having to call
`lispPackagesFor` if all you want is a Lisp-with-packages wrapper.
#### Required Arguments
##### `lisp`
The Lisp command to pass to `lispPackagesFor` in order for it to
generate a package set. That set is then passed to
`lispWithPackagesInternal`.
#### Return value
A Lisp-with-packages function (see sections above).
#### Example
The [abcl-with-packages.nix] example creates an `abclWithPackages` function.
[abcl-with-packages.nix]: /examples/abcl-with-packages.nix
## Using the default Lisp implementations
This is the easiest way to get going with `nix-cl` in general. Choose
the CL implementation of interest and a set of libraries, and get a
lisp-with-packages wrapper with those libraries pre-compiled.
#### `abclPackages`, `eclPackages`, `cclPackages`, `claspPackages`, `sbclPackages`
Ready to use package sets.
#### `abclWithPackages`, `eclWithPackages`, `cclWithPackages`, `claspWithPackages`, `sbclWithPackages`
Ready to use wrapper generators.
#### Example
For example, to open a shell with SBCL + hunchentoot + sqlite in PATH:
```
nix-shell -p 'with import ./. {}; sbclWithPackages (ps: [ ps.hunchentoot ps.sqlite ])'
```

98
pkgs/development/lisp-modules-new-obsolete/doc/nix-cl.md
View file

@ -1,98 +0,0 @@
## Use cases
This page lists some possible use cases for nix-cl.
## Pinning down the exact commits of libraries
Sometimes, a bug is fixed upstream but is not yet available in package
repositories such as Quicklisp or Ultralisp. The users have to wait
for the repository maintainer to update it, or download and compile
the patched sources themselves.
This is a manual and hard to reproduce process. By leveraging Nix,
users of `nix-cl` can essentially "run their own package repository",
written as Nix code, with all the benefits of that (shareability,
cacheability, reproducibility, version-controllable etc.)
## Modifying libraries with patches
Other times, a bug in a library is not fixed upstream, but you fixed
it yourself. Or, you would like a change to the internals that the
maintainers don't like.
Sure, you could fork the code or maintain patches manually, but that
becomes hard to manage with a lot of patches. It also doesn't have the
benefits mentioned in the previous section.
`nix-cl` provides a way of applying version-controlled patches to any
package.
## Using libraries not available in repositories
There are useful and working libraries out there, that are nonetheless
unavailable to users of package managers such as Quicklisp or
Ultralisp. Two real-world examples are [jzon] and [cl-tar].
`nix-cl` is not tied to any particular package source: instead,
packages are written as a Nix expression, which can be done manually
or generated/imported.
This frees the user to have any package they want, and not be
constrained by a central repository.
## Reproducible environments
The usual way to develop a project involves several steps, such as:
1. Installing a Lisp implementation
2. Installing a package manager
3. Installing the chosen libraries
This is not necessarily reproducible. It's unlikely to come back a
year later and develop the project using the exact same versions of
the dependencies.
Things can break between attempts at different points in time. The
repository could have updated versions in the meantime. The source
tarballs could become unreachable.
With `nix-cl` you can have your own binary cache for Lisp libraries
and not be affected by downtime of other central repositories.
## Testing across CL implementations
One can manually download different Lisp implementations and run tests
of a package. This works well in most cases, but it is limited in how
you can tweak the software. Some practical examples are:
- Statically compiling [zlib] into [SBCL]
- Building SBCL with the `--fancy` flag
- Compiling [ECL] as a static library
These are usually hard to do manually, unless you have the necessary
compilers already configured. These combinations are usually not
available from package managers as well.
With Nix it's easier, because it will set up the build environment
automatically. It could be useful to, for example:
- Test against all possible compiler flag combinations
- Libc versions (ECL)
- JDK versions ([ABCL])
[zlib]: https://zlib.net
[SBCL]: https://sbcl.org
[ECL]: https://ecl.common-lisp.dev/
[Ultralisp]: https://ultralisp.org/
[jzon]: https://github.com/Zulu-Inuoe/jzon
[cl-tar]: https://gitlab.common-lisp.net/cl-tar/cl-tar
[bootstrap tools]: https://github.com/NixOS/nixpkgs/tree/master/pkgs/stdenv/linux/bootstrap-files
[nixpkgs]: https://github.com/NixOS/nixpkgs
## Windows note
Note that all of this still only applies to Unix systems - primarily because Nix doesn't work on Windows.
If you have an idea how to port some of the functionality to Windows, get in touch.

54
pkgs/development/lisp-modules-new-obsolete/doc/quicklisp.md
View file

@ -1,54 +0,0 @@
## Importing package definitions from Quicklisp
This page documents how to import packages from Quicklisp.
## Nix dumper
Run:
```
$ nix-shell
$ sbcl --script ql-import.lisp
```
This command runs a program that dumps a `imported.nix` file
containing Nix expressions for all packages in Quicklisp. They will be
automatically picked up by the `lispPackagesFor` and
`lispWithPackages` API functions.
It also creates a 'packages.sqlite' file. It's used during the
generation of the 'imported.nix' file and can be safely removed. It
contains the full information of Quicklisp packages, so you can use it
to query the dependency graphs using SQL, if you're interested.
## Tarball hashes
The Nix dumper program will re-use hashes from "imported.nix" if it
detects that it's being run for the first time. This saves a lot of
bandwidth by not having to download each tarball again.
But when upgrading the Quicklisp release URL, this can take a while
because it needs to fetch the source code of each new system to
compute its SHA256 hash. This is because Quicklisp only provides a
SHA1 , and Nix's `builtins.fetchTarball` requires a SHA256.
Later on, the hashes are cached in `packages.sqlite`, and are reused
in subsequent invocations. Therefore you might want to keep the
'packages.sqlite' file around if you'd like to keep hashes of
historical Quicklisp tarballs, for example for archival purposes.
## Choosing a Quicklisp release
Quicklisp release url's are currently hard-coded and can be changed
directly in the source code. See the `import` directory.
## Native and Java libraries
At the moment, native and Java libraries need to be added manually to
imported systems in `ql.nix` on an as-needed basis.
## Dependencies from packages.nix
Also worth noting is that systems imported from Quicklisp will prefer
packages from `packages.nix` as dependencies, so that custom versions
can be provided or broken versions replaced.

5
pkgs/development/lisp-modules-new-obsolete/doc/quirks.md
View file

@ -1,5 +0,0 @@
## Quirks
- `+` in names are converted to `_plus{_,}`: `cl+ssl`->`cl_plus_ssl`, `alexandria+`->`alexandria_plus`
- `.` to `_dot_`: `iolib.base`->`iolib_dot_base`
- names starting with a number have a `_` prepended (`3d-vectors`->`_3d-vectors`)

24
pkgs/development/lisp-modules-new-obsolete/examples/abcl-package-set.nix
View file

@ -1,24 +0,0 @@
# To run this example from a nix repl, run:
# $ nix repl
# nix-repl> abcl-packages = import ./abcl-package-set.nix
# nix-repl> builtins.attrNames abcl-packages
# nix-repl> builtins.length (builtins.attrNames abcl-packages)
#
# The import returns a package set, which you can use for example to
# discover what packages are available in lispWithPackages:
#
# nix-repl> abcl-packages.cl-op<TAB>
# nix-repl> abcl-packages.cl-opengl
# nix-repl> # cool, we can use cl-opengl
# nix-repl> # some-abcl-with-packages (p: [ p.cl-opengl ])
let
pkgs = import ../../../../default.nix {};
abcl = "${pkgs.abcl}/bin/abcl --batch --load";
abcl-packages = pkgs.lispPackages_new.lispPackagesFor abcl;
in abcl-packages

23
pkgs/development/lisp-modules-new-obsolete/examples/abcl-with-packages.nix
View file

@ -1,23 +0,0 @@
# To run this example from a nix repl, run:
# $ nix repl
# nix-repl> abcl-with-packages = import ./abcl-with-packages.nix
# nix-repl> :b abcl-with-packages (p: [ p.cffi ])
#
# The import returns a function, which you can call to get access to
# thousands of libraries, like, cffi. This works in ABCL by closing
# over the JNA dependency:
#
# nix-repl> awp = abcl-with-packages (p: [ p.cffi ])
# nix-repl> awp.CLASSPATH
# nix-repl> cffi = builtins.head (awp.lispLibs)
# nix-repl> cffi.javaLibs
let
pkgs = import ../../../../default.nix {};
abcl = "${pkgs.abcl}/bin/abcl --batch --load";
abcl-with-packages = pkgs.lispPackages_new.lispWithPackages abcl;
in abcl-with-packages

43
pkgs/development/lisp-modules-new-obsolete/examples/bordeaux-threads.nix
View file

@ -1,43 +0,0 @@
# To run this example from the command line, run this command:
#
# $ nix-build ./bordeaux-threads.nix
# $ ls ./result/
#
# To run from a nix repl, run:
# $ nix repl
# nix-repl> bt = import ./bordeaux-threads.nix
# nix-repl> :b bt
#
# In the `result` directory you can find .fasl files of the
# bordeaux-threads library:
#
# $ ls -l ./result/src/
let
pkgs = import ../../../../default.nix {};
sbcl = "${pkgs.sbcl}/bin/sbcl --script";
alexandria = pkgs.lispPackages_new.build-asdf-system {
pname = "alexandria";
version = "v1.4";
src = pkgs.fetchzip {
url = "https://gitlab.common-lisp.net/alexandria/alexandria/-/archive/v1.4/alexandria-v1.4.tar.gz";
sha256 = "0r1adhvf98h0104vq14q7y99h0hsa8wqwqw92h7ghrjxmsvz2z6l";
};
lisp = sbcl;
};
bordeaux-threads = pkgs.lispPackages_new.build-asdf-system {
pname = "bordeaux-threads";
version = "0.8.8";
src = pkgs.fetchzip {
url = "https://github.com/sionescu/bordeaux-threads/archive/v0.8.8.tar.gz";
sha256 = "19i443fz3488v1pbbr9x24y8h8vlyhny9vj6c9jk5prm702awrp6";
};
lisp = sbcl;
lispLibs = [ alexandria ];
};
in bordeaux-threads

31
pkgs/development/lisp-modules-new-obsolete/examples/sbcl-with-bt.nix
View file

@ -1,31 +0,0 @@
# To run this example from the command line, run this command:
# $ nix-build ./sbcl-with-bt.nix
# $ ls ./result/
#
# To run from a nix repl, run:
# $ nix repl
# nix-repl> sbcl-bt = import ./sbcl-with-bt.nix
# nix-repl> :b sbcl-bt
#
# In the `result/bin` directory you can find an `sbcl` executable
# that, when started, is able to load the pre-compiled
# bordeaux-threads from the Nix store:
# $ ./result/bin/sbcl
# * (require :asdf)
# * (asdf:load-system :bordeaux-threads)
let
pkgs = import ../../../../default.nix {};
sbcl = "${pkgs.sbcl}/bin/sbcl --script";
bordeaux-threads = import ./bordeaux-threads.nix;
sbclPackages = { inherit bordeaux-threads; };
sbclWithPackages = pkgs.lispPackages_new.lispWithPackagesInternal sbclPackages;
sbcl-bt = sbclWithPackages (p: [ p.bordeaux-threads ]);
in sbcl-bt

18
pkgs/development/lisp-modules-new-obsolete/import/api.lisp
View file

@ -1,18 +0,0 @@
(defpackage org.lispbuilds.nix/api
(:documentation "Public interface of org.lispbuilds.nix")
(:use :cl)
(:export
:import-lisp-packages
:database->nix-expression))
(in-package org.lispbuilds.nix/api)
(defgeneric import-lisp-packages (repository database)
(:documentation
"Import Lisp packages (ASDF systems) from repository (Quicklisp,
Ultralisp etc.) into a package database."))
(defgeneric database->nix-expression (database outfile)
(:documentation
"Generate a nix expression from the package database and write it
into outfile."))

162
pkgs/development/lisp-modules-new-obsolete/import/database/sqlite.lisp
View file

@ -1,162 +0,0 @@
(defpackage org.lispbuilds.nix/database/sqlite
(:use :cl)
(:import-from :str)
(:import-from :sqlite)
(:import-from :alexandria :read-file-into-string)
(:import-from :arrow-macros :->>)
(:import-from
:org.lispbuilds.nix/util
:replace-regexes)
(:import-from
:org.lispbuilds.nix/nix
:nix-eval
:system-master
:nixify-symbol
:make-pname
:*nix-attrs-depth*)
(:import-from
:org.lispbuilds.nix/api
:database->nix-expression)
(:export :sqlite-database :init-db)
(:local-nicknames
(:json :com.inuoe.jzon)))
(in-package org.lispbuilds.nix/database/sqlite)
(defclass sqlite-database ()
((url :initarg :url
:reader database-url
:initform (error "url required"))
(init-file :initarg :init-file
:reader init-file
:initform (error "init file required"))))
(defun init-db (db init-file)
(let ((statements (->> (read-file-into-string init-file)
(replace-regexes '(".*--.*") '(""))
(substitute #\Space #\Newline)
(str:collapse-whitespaces)
(str:split #\;)
(mapcar #'str:trim)
(remove-if #'str:emptyp))))
(sqlite:with-transaction db
(dolist (s statements)
(sqlite:execute-non-query db s)))))
;; Writing Nix
(defparameter prelude "
# This file was auto-generated by nix-quicklisp.lisp
{ runCommand, fetchzip, pkgs, ... }:
# Ensures that every non-slashy `system` exists in a unique .asd file.
# (Think cl-async-base being declared in cl-async.asd upstream)
#
# This is required because we're building and loading a system called
# `system`, not `asd`, so otherwise `system` would not be loadable
# without building and loading `asd` first.
#
let createAsd = { url, sha256, asd, system }:
let
src = fetchzip { inherit url sha256; };
in runCommand \"source\" {} ''
mkdir -pv $out
cp -r ${src}/* $out
find $out -name \"${asd}.asd\" | while read f; do mv -fv $f $(dirname $f)/${system}.asd || true; done
'';
getAttr = builtins.getAttr;
in {")
;; Random compilation errors
(defparameter +broken-packages+
(list
;; no dispatch function defined for #\t
"hu.dwim.logger"
"hu.dwim.serializer"
"hu.dwim.quasi-quote"
;; Tries to write in $HOME
"ubiquitous"
"math"
;; Upstream bad packaging, multiple systems in clml.blas.asd
"clml.blas.hompack"
;; Fails on SBCL due to heap exhaustion
"magicl"
;; Probably missing dependency in QL data
"mcclim-bezier"
;; Missing dependency on c2ffi cffi extension
"hu.dwim.zlib"
;; Missing libgvc.so native library
"hu.dwim.graphviz"
;; These require libRmath.so, but I don't know where to get it from
"cl-random"
"cl-random-tests"
))
(defmethod database->nix-expression ((database sqlite-database) outfile)
(sqlite:with-open-database (db (database-url database))
(with-open-file (f outfile
:direction :output
:if-exists :supersede)
;; Fix known problematic packages before dumping the nix file.
(sqlite:execute-non-query db
"create temp table fixed_systems as select * from system_view")
(sqlite:execute-non-query db
"alter table fixed_systems add column systems")
(sqlite:execute-non-query db
"update fixed_systems set systems = json_array(name)")
(sqlite:execute-non-query db
"alter table fixed_systems add column asds")
(sqlite:execute-non-query db
"update fixed_systems set asds = json_array(name)")
(format f prelude)
(dolist (p (sqlite:execute-to-list db "select * from fixed_systems"))
(destructuring-bind (name version asd url sha256 deps systems asds) p
(format f "~% ")
(let ((*nix-attrs-depth* 1))
(format
f
"~a = ~a;"
(nix-eval `(:symbol ,name))
(nix-eval
`(:attrs
("pname" (:string ,(make-pname name)))
("version" (:string ,version))
("asds" (:list
,@(mapcar (lambda (asd)
`(:string ,(system-master asd)))
(coerce (json:parse asds) 'list))))
("src" (:funcall
"createAsd"
(:attrs
("url" (:string ,url))
("sha256" (:string ,sha256))
("system" (:string ,(system-master name)))
("asd" (:string ,asd)))))
("systems" (:list
,@(mapcar (lambda (sys)
`(:string ,sys))
(coerce (json:parse systems) 'list))))
("lispLibs" (:list
,@(mapcar (lambda (dep)
`(:funcall
"getAttr"
(:string ,(nixify-symbol dep))
(:symbol "pkgs")))
(remove "asdf"
(str:split-omit-nulls #\, deps)
:test #'string=))))
,@(when (or (find #\/ name)
(find name +broken-packages+ :test #'string=))
'(("meta" (:attrs ("broken" (:symbol "true"))))))))))))
(format f "~%}~%"))))

41
pkgs/development/lisp-modules-new-obsolete/import/init.sql
View file

@ -1,41 +0,0 @@
CREATE TABLE IF NOT EXISTS sha256 (
id integer PRIMARY KEY AUTOINCREMENT,
url text UNIQUE,
hash text NOT NULL,
created real DEFAULT (julianday('now'))
);
CREATE TABLE IF NOT EXISTS system (
id integer PRIMARY KEY AUTOINCREMENT,
name text NOT NULL,
version text NOT NULL,
asd text NOT NULL,
created real DEFAULT (julianday('now')),
UNIQUE(name, version)
);
CREATE TABLE IF NOT EXISTS dep (
system_id integer NOT NULL REFERENCES system(id),
dep_id integer NOT NULL REFERENCES system(id),
PRIMARY KEY (system_id, dep_id)
);
CREATE TABLE IF NOT EXISTS src (
sha256_id integer REFERENCES sha256(id),
system_id integer UNIQUE REFERENCES system(id)
);
DROP VIEW IF EXISTS system_view;
CREATE VIEW IF NOT EXISTS system_view AS
SELECT
sys.name,
sys.version,
sys.asd,
sha.url,
sha.hash,
group_concat((SELECT name FROM system WHERE id = dep.dep_id)) as deps
FROM system sys
JOIN src ON src.system_id = sys.id
JOIN sha256 sha ON sha.id = src.sha256_id
LEFT JOIN dep ON dep.system_id = sys.id
GROUP BY sys.name;

40
pkgs/development/lisp-modules-new-obsolete/import/main.lisp
View file

@ -1,40 +0,0 @@
(defpackage org.lispbuilds.nix/main
(:use :common-lisp
:org.lispbuilds.nix/database/sqlite
:org.lispbuilds.nix/repository/quicklisp
:org.lispbuilds.nix/api))
(in-package org.lispbuilds.nix/main)
(defun resource (name type)
(make-pathname
:defaults (asdf:system-source-directory :org.lispbuilds.nix)
:name name
:type type))
(defvar *sqlite*
(make-instance
'sqlite-database
:init-file (resource "init" "sql")
:url "packages.sqlite"))
(defvar *quicklisp*
(make-instance
'quicklisp-repository
:dist-url
"https://beta.quicklisp.org/dist/quicklisp/2022-11-07/"))
(defun run-importers ()
(import-lisp-packages *quicklisp* *sqlite*)
(format t "Imported packages from quicklisp to ~A~%"
(truename "packages.sqlite")))
(defun gen-nix-file ()
(database->nix-expression *sqlite* "imported.nix")
(format t "Dumped nix file to ~a~%"
(truename "imported.nix")))
(defun main ()
(format t "~%")
(run-importers)
(gen-nix-file))

81
pkgs/development/lisp-modules-new-obsolete/import/nix.lisp
View file

@ -1,81 +0,0 @@
(defpackage org.lispbuilds.nix/nix
(:documentation "Utilities for generating Nix code")
(:use :cl)
(:import-from :str)
(:import-from :ppcre)
(:import-from :arrow-macros :->>)
(:import-from :org.lispbuilds.nix/util :replace-regexes)
(:export
:nix-eval
:system-master
:nixify-symbol
:make-pname
:*nix-attrs-depth*))
(in-package org.lispbuilds.nix/nix)
;; Path names are alphanumeric and can include the symbols +-._?= and
;; must not begin with a period.
(defun make-pname (string)
(replace-regexes '("^[.]" "[^a-zA-Z0-9+-._?=]")
'("_" "_")
string))
(defun system-master (system)
(first (str:split "/" system)))
;;;; Nix generation
(defun nix-eval (exp)
(assert (consp exp))
(ecase (car exp)
(:string (nix-string (cadr exp)))
(:list (apply #'nix-list (rest exp)))
(:funcall (apply #'nix-funcall (rest exp)))
(:attrs (nix-attrs (cdr exp)))
(:merge (apply #'nix-merge (cdr exp)))
(:symbol (nix-symbol (cadr exp)))))
(defun nix-string (object)
(format nil "\"~a\"" object))
(defun nixify-symbol (string)
(flet ((fix-special-chars (str)
(replace-regexes '("[+]$" "[+][/]" "[+]" "[.]" "[/]")
'("_plus" "_plus/" "_plus_" "_dot_" "_slash_")
str)))
(if (ppcre:scan "^[0-9]" string)
(str:concat "_" (fix-special-chars string))
(fix-special-chars string))))
(defun nix-symbol (object)
(nixify-symbol (format nil "~a" object)))
(defun nix-list (&rest things)
(format nil "[ ~{~A~^ ~} ]" (mapcar 'nix-eval things)))
(defvar *nix-attrs-depth* 0)
(defun nix-attrs (keyvals)
(let ((*nix-attrs-depth* (1+ *nix-attrs-depth*)))
(format
nil
(->> "{~%*depth*~{~{~A = ~A;~}~^~%*depth*~}~%*depth-1*}"
(str:replace-all "*depth*" (str:repeat *nix-attrs-depth* " "))
(str:replace-all "*depth-1*" (str:repeat (1- *nix-attrs-depth*) " ")))
(mapcar (lambda (keyval)
(let ((key (car keyval))
(val (cadr keyval)))
(list (nix-symbol key)
(nix-eval val))))
keyvals))))
(defun nix-funcall (fun &rest args)
(format nil "(~a ~{~a~^ ~})"
(nixify-symbol fun)
(mapcar 'nix-eval args)))
(defun nix-merge (a b)
(format nil "(~a // ~b)"
(nix-eval a)
(nix-eval b)))

24
pkgs/development/lisp-modules-new-obsolete/import/org.lispbuilds.nix.asd
View file

@ -1,24 +0,0 @@
(defsystem org.lispbuilds.nix
:class :package-inferred-system
:description "Utilities for importing ASDF systems into Nix"
:depends-on (
:alexandria
:str
:cl-ppcre
:sqlite
:dexador
:arrow-macros
:com.inuoe.jzon
:org.lispbuilds.nix/api
:org.lispbuilds.nix/repository/quicklisp
:org.lispbuilds.nix/database/sqlite
))
(register-system-packages
"cl-ppcre"
'(:ppcre))
(register-system-packages
"dexador"
'(:dex))

199
pkgs/development/lisp-modules-new-obsolete/import/repository/quicklisp.lisp
View file

@ -1,199 +0,0 @@
(defpackage org.lispbuilds.nix/repository/quicklisp
(:use :cl)
(:import-from :dex)
(:import-from :alexandria :read-file-into-string :ensure-list)
(:import-from :arrow-macros :->>)
(:import-from :str)
(:import-from
:org.lispbuilds.nix/database/sqlite
:sqlite-database
:init-db
:database-url
:init-file)
(:import-from
:org.lispbuilds.nix/api
:import-lisp-packages)
(:import-from
:org.lispbuilds.nix/util
:replace-regexes)
(:export :quicklisp-repository)
(:local-nicknames
(:json :com.inuoe.jzon)))
(in-package org.lispbuilds.nix/repository/quicklisp)
(defclass quicklisp-repository ()
((dist-url :initarg :dist-url
:reader dist-url
:initform (error "dist url required"))))
(defun clear-line ()
(write-char #\Return *error-output*)
(write-char #\Escape *error-output*)
(write-char #\[ *error-output*)
(write-char #\K *error-output*))
(defun status (&rest format-args)
(clear-line)
(apply #'format (list* *error-output* format-args))
(force-output *error-output*))
;; TODO: This should not know about the imported.nix file.
(defun init-tarball-hashes (database)
(status "no packages.sqlite - will pre-fill tarball hashes from ~A to save time~%"
(truename "imported.nix"))
(let* ((lines (uiop:read-file-lines "imported.nix"))
(lines (remove-if-not
(lambda (line)
(let ((trimmed (str:trim-left line)))
(or (str:starts-with-p "url = " trimmed)
(str:starts-with-p "sha256 = " trimmed))))
lines))
(lines (mapcar
(lambda (line)
(multiple-value-bind (whole groups)
(ppcre:scan-to-strings "\"\(.*\)\"" line)
(declare (ignore whole))
(svref groups 0)))
lines)))
(sqlite:with-open-database (db (database-url database))
(init-db db (init-file database))
(sqlite:with-transaction db
(loop while lines do
(sqlite:execute-non-query db
"insert or ignore into sha256(url,hash) values (?,?)"
(prog1 (first lines) (setf lines (rest lines)))
(prog1 (first lines) (setf lines (rest lines))))))
(status "OK, imported ~A hashes into DB.~%"
(sqlite:execute-single db
"select count(*) from sha256")))))
(defmethod import-lisp-packages ((repository quicklisp-repository)
(database sqlite-database))
;; If packages.sqlite is missing, we should populate the sha256
;; table to speed things up.
(unless (probe-file (database-url database))
(init-tarball-hashes database))
(let* ((db (sqlite:connect (database-url database)))
(systems-url (str:concat (dist-url repository) "systems.txt"))
(releases-url (str:concat (dist-url repository) "releases.txt"))
(systems-lines (rest (butlast (str:split #\Newline (dex:get systems-url)))))
(releases-lines (rest (butlast (str:split #\Newline (dex:get releases-url))))))
(flet ((sql-query (sql &rest params)
(apply #'sqlite:execute-to-list (list* db sql params))))
;; Ensure database schema
(init-db db (init-file database))
;; Prepare temporary tables for efficient access
(sql-query "create temp table if not exists quicklisp_system
(project, asd, name unique, deps)")
(sql-query "create temp table if not exists quicklisp_release
(project unique, url, size, md5, sha1, prefix not null, asds)")
(sqlite:with-transaction db
(dolist (line systems-lines)
(destructuring-bind (project asd name &rest deps)
(str:words line)
(sql-query
"insert or ignore into quicklisp_system values(?,?,?,?)"
project asd name (json:stringify (coerce deps 'vector))))))
(sqlite:with-transaction db
(dolist (line releases-lines)
(destructuring-bind (project url size md5 sha1 prefix &rest asds)
(str:words line)
(sql-query
"insert or ignore into quicklisp_release values(?,?,?,?,?,?,?)"
project url size md5 sha1 prefix (json:stringify (coerce
asds
'vector))))))
(sqlite:with-transaction db
;; Should these be temp tables, that then get queried by
;; system name? This looks like it uses a lot of memory.
(let ((systems
(sql-query
"with pkg as (
select
name, asd, url, deps,
ltrim(replace(prefix, r.project, ''), '-_') as version
from quicklisp_system s, quicklisp_release r
where s.project = r.project
)
select
name, version, asd, url,
(select json_group_array(
json_array(value, (select version from pkg where name=value))
)
from json_each(deps)) as deps
from pkg"
)))
;; First pass: insert system and source tarball informaton.
;; Can't insert dependency information, because this works
;; on system ids in the database and they don't exist
;; yet. Could it be better to just base dependencies on
;; names? But then ACID is lost.
(dolist (system systems)
(destructuring-bind (name version asd url deps) system
(declare (ignore deps))
(status "importing system '~a-~a'" name version)
(let ((hash (nix-prefetch-tarball url db)))
(sql-query
"insert or ignore into system(name,version,asd) values (?,?,?)"
name version asd)
(sql-query
"insert or ignore into sha256(url,hash) values (?,?)"
url hash)
(sql-query
"insert or ignore into src values
((select id from sha256 where url=?),
(select id from system where name=? and version=?))"
url name version))))
;; Second pass: connect the in-database systems with
;; dependency information
(dolist (system systems)
(destructuring-bind (name version asd url deps) system
(declare (ignore asd url))
(dolist (dep (coerce (json:parse deps) 'list))
(destructuring-bind (dep-name dep-version) (coerce dep 'list)
(if (eql dep-version 'NULL)
(warn "Bad data in Quicklisp: ~a has no version" dep-name)
(sql-query
"insert or ignore into dep values
((select id from system where name=? and version=?),
(select id from system where name=? and version=?))"
name version
dep-name dep-version))))))))))
(write-char #\Newline *error-output*))
(defun shell-command-to-string (cmd)
;; Clearing the library path is needed to prevent a bug, where the
;; called subprocess uses a different glibc than the SBCL process
;; is. In that case, the call to execve attempts to load the
;; libraries used by SBCL from LD_LIBRARY_PATH using a different
;; glibc than they expect, which errors out.
(let ((ld-library-path (uiop:getenv "LD_LIBRARY_PATH")))
(setf (uiop:getenv "LD_LIBRARY_PATH") "")
(unwind-protect
(uiop:run-program cmd :output '(:string :stripped t))
(setf (uiop:getenv "LD_LIBRARY_PATH") ld-library-path))))
(defun nix-prefetch-tarball (url db)
(restart-case
(compute-sha256 url db)
(try-again ()
:report "Try downloading again"
(nix-prefetch-tarball url db))))
(defun compute-sha256 (url db)
(or (sqlite:execute-single db "select hash from sha256 where url=?" url)
(let ((sha256 (shell-command-to-string (str:concat "nix-prefetch-url --unpack " url))))
sha256)))

16
pkgs/development/lisp-modules-new-obsolete/import/util.lisp
View file

@ -1,16 +0,0 @@
(defpackage org.lispbuilds.nix/util
(:use :cl)
(:import-from :ppcre)
(:export
:replace-regexes))
(in-package org.lispbuilds.nix/util)
(defun replace-regexes (from to str)
(assert (= (length from) (length to)))
(if (null from)
str
(replace-regexes
(rest from)
(rest to)
(ppcre:regex-replace-all (first from) str (first to)))))

72088
pkgs/development/lisp-modules-new-obsolete/imported.nix
View file

File diff suppressed because it is too large Load diff

418
pkgs/development/lisp-modules-new-obsolete/lisp-packages.nix
View file

@ -1,418 +0,0 @@
# TODO:
# - faster build by using lisp with preloaded asdf?
# - dont include java libs unless abcl?
# - dont use build-asdf-system to build lispWithPackages?
# - make the lisp packages overridable? (e.g. buildInputs glibc->musl)
# - build asdf with nix and use that instead of one shipped with impls
# (e.g. to fix build with clisp - does anyone use clisp?)
# - claspPackages ? (gotta package clasp with nix first)
# - hard one: remove unrelated sources ( of systems not being built)
# - figure out a less awkward way to patch sources
# (have to build from src directly for SLIME to work, so can't just patch sources in place)
{ pkgs, lib, stdenv, ... }:
let
inherit (lib)
length
filter
foldl
unique
id
concat
concatMap
mutuallyExclusive
findFirst
remove
setAttr
getAttr
hasAttr
attrNames
attrValues
filterAttrs
mapAttrs
splitString
concatStringsSep
concatMapStringsSep
replaceStrings
removeSuffix
hasInfix
optionalString
makeBinPath
makeLibraryPath
makeSearchPath
recurseIntoAttrs
dontRecurseIntoAttrs
;
inherit (builtins)
head
tail
elem
split
storeDir;
# Returns a flattened dependency tree without duplicates
# This is probably causing performance problems...
flattenedDeps = lispLibs:
let
toSet = list: builtins.listToAttrs (map (d: { name = d.pname; value = d; }) list);
toList = attrValues;
walk = acc: node:
if length node.lispLibs == 0
then acc
else builtins.foldl' walk (acc // toSet node.lispLibs) node.lispLibs;
in toList (walk {} { inherit lispLibs; });
# Stolen from python-packages.nix
# Actually no idea how this works
makeOverridableLispPackage = f: origArgs:
let
ff = f origArgs;
overrideWith = newArgs: origArgs // (if pkgs.lib.isFunction newArgs then newArgs origArgs else newArgs);
in
if builtins.isAttrs ff then (ff // {
overrideLispAttrs = newArgs: makeOverridableLispPackage f (overrideWith newArgs);
})
else if builtins.isFunction ff then {
overrideLispAttrs = newArgs: makeOverridableLispPackage f (overrideWith newArgs);
__functor = self: ff;
}
else ff;
#
# Wrapper around stdenv.mkDerivation for building ASDF systems.
#
build-asdf-system =
(makeOverridableLispPackage (
{ pname,
version,
src ? null,
patches ? [],
# Native libraries, will be appended to the library path
nativeLibs ? [],
# Java libraries for ABCL, will be appended to the class path
javaLibs ? [],
# Lisp dependencies
# these should be packages built with `build-asdf-system`
lispLibs ? [],
# Lisp command to run buildScript
lisp,
# Some libraries have multiple systems under one project, for
# example, cffi has cffi-grovel, cffi-toolchain etc. By
# default, only the `pname` system is build.
#
# .asd's not listed in `systems` are removed in
# installPhase. This prevents asdf from referring to uncompiled
# systems on run time.
#
# Also useful when the pname is differrent than the system name,
# such as when using reverse domain naming.
systems ? [ pname ],
# The .asd files that this package provides
asds ? systems,
# Other args to mkDerivation
...
} @ args:
let
# A little slow for big dependency graphs.
# How to make it faster?
# Maybe do it in the buildScript in Common Lisp or Bash, instead
# of here with Nix?
libsFlat = flattenedDeps lispLibs;
in stdenv.mkDerivation (rec {
inherit pname version nativeLibs javaLibs lispLibs lisp systems asds;
# When src is null, we are building a lispWithPackages and only
# want to make use of the dependency environment variables
# generated by build-asdf-system
dontUnpack = src == null;
# TODO: Do the propagation like for lisp, native and java like this:
# https://github.com/teu5us/nix-lisp-overlay/blob/e30dafafa5c1b9a5b0ccc9aaaef9d285d9f0c46b/pkgs/development/lisp-modules/setup-hook.sh
# Then remove the "echo >> nix-drvs" from buildScript
# Tell asdf where to find system definitions of lisp dependencies.
#
# The "//" ending is important as it makes asdf recurse into
# subdirectories when searching for .asd's. This is to support
# projects where .asd's aren't in the root directory.
CL_SOURCE_REGISTRY = makeSearchPath "/" libsFlat;
# Tell lisp where to find native dependencies
#
# Normally generated from lispLibs, but LD_LIBRARY_PATH as a
# derivation attr itself can be used as an extension point when
# the libs are not in a '/lib' subdirectory
LD_LIBRARY_PATH =
let
libs = concatMap (x: x.nativeLibs) libsFlat;
paths = filter (x: x != "") (map (x: x.LD_LIBRARY_PATH) libsFlat);
path =
makeLibraryPath libs
+ optionalString (length paths != 0) ":"
+ concatStringsSep ":" paths;
in concatStringsSep ":" (unique (splitString ":" path));
# Java libraries For ABCL
CLASSPATH = makeSearchPath "share/java/*" (concatMap (x: x.javaLibs) libsFlat);
# Portable script to build the systems.
#
# `lisp` must evaluate this file then exit immediately. For
# example, SBCL's --script flag does just that.
#
# NOTE:
# Every other library worked fine with asdf:compile-system in
# buildScript.
#
# cl-syslog, for some reason, signals that CL-SYSLOG::VALID-SD-ID-P
# is undefined with compile-system, but works perfectly with
# load-system. Strange.
buildScript = pkgs.writeText "build-${pname}.lisp" ''
(require :asdf)
(dolist (s '(${concatStringsSep " " systems}))
(asdf:load-system s))
'';
buildPhase = optionalString (src != null) ''
# In addition to lisp dependencies, make asdf see the .asd's
# of the systems being built
#
# *Append* src since `lispLibs` can provide .asd's that are
# also in `src` but are not in `systems` (that is, the .asd's
# that will be deleted in installPhase). We don't want to
# rebuild them, but to load them from lispLibs.
#
# NOTE: It's important to read files from `src` instead of
# from pwd to get go-to-definition working with SLIME
export CL_SOURCE_REGISTRY=$CL_SOURCE_REGISTRY:$src//
# Similiarily for native deps
export LD_LIBRARY_PATH=${makeLibraryPath nativeLibs}:$LD_LIBRARY_PATH
export CLASSPATH=${makeSearchPath "share/java/*" javaLibs}:$CLASSPATH
# Make asdf compile from `src` to pwd and load `lispLibs`
# from storeDir. Otherwise it could try to recompile lisp deps.
export ASDF_OUTPUT_TRANSLATIONS="$src:$(pwd):${storeDir}:${storeDir}"
# track lisp dependencies for graph generation
# TODO: Do the propagation like for lisp, native and java like this:
# https://github.com/teu5us/nix-lisp-overlay/blob/e30dafafa5c1b9a5b0ccc9aaaef9d285d9f0c46b/pkgs/development/lisp-modules/setup-hook.sh
# Then remove the "echo >> nix-drvs" from buildScript
echo $lispLibs >> __nix-drvs
# Finally, compile the systems
${lisp} $buildScript
'';
# Copy compiled files to store
#
# Make sure to include '$' in regex to prevent skipping
# stuff like 'iolib.asdf.asd' for system 'iolib.asd'
#
# Same with '/': `local-time.asd` for system `cl-postgres+local-time.asd`
installPhase =
let
mkSystemsRegex = systems:
concatMapStringsSep "\\|" (replaceStrings ["." "+"] ["[.]" "[+]"]) systems;
in
''
mkdir -pv $out
cp -r * $out
# Remove all .asd files except for those in `systems`.
find $out -name "*.asd" \
| grep -v "/\(${mkSystemsRegex systems}\)\.asd$" \
| xargs rm -fv || true
'';
# Not sure if it's needed, but caused problems with SBCL
# save-lisp-and-die binaries in the past
dontStrip = true;
dontFixup = true;
} // (args // {
src = if builtins.length (args.patches or []) > 0
then pkgs.applyPatches { inherit (args) src patches; }
else args.src;
patches = [];
# make sure that propagated build-inputs from lispLibs are propagated
propagatedBuildInputs = lib.unique
(builtins.concatLists
(lib.catAttrs "propagatedBuildInputs"
(builtins.concatLists [[args] lispLibs nativeLibs javaLibs])));
}))));
# Build the set of lisp packages using `lisp`
# These packages are defined manually for one reason or another:
# - The library is not in quicklisp
# - The library that is in quicklisp is broken
# - Special build procedure such as cl-unicode, asdf
#
# These Probably could be done even in ql.nix
# - Want to pin a specific commit
# - Want to apply custom patches
#
# They can use the auto-imported quicklisp packages as dependencies,
# but some of those don't work out of the box.
#
# E.g if a QL package depends on cl-unicode it won't build out of
# the box. The dependency has to be rewritten using the manually
# fixed cl-unicode.
#
# This is done by generating a 'fixed' set of Quicklisp packages by
# calling quicklispPackagesFor with the right `fixup`.
commonLispPackagesFor = lisp:
let
build-asdf-system' = body: build-asdf-system (body // { inherit lisp; });
in import ./packages.nix {
inherit pkgs;
inherit lisp;
inherit quicklispPackagesFor;
inherit fixupFor;
build-asdf-system = build-asdf-system';
};
# Build the set of packages imported from quicklisp using `lisp`
quicklispPackagesFor = { lisp, fixup ? lib.id, build ? build-asdf-system }:
let
build-asdf-system' = body: build (body // {
inherit lisp;
});
in import ./ql.nix {
inherit pkgs;
inherit fixup;
build-asdf-system = build-asdf-system';
};
# Rewrite deps of pkg to use manually defined packages
#
# The purpose of manual packages is to customize one package, but
# then it has to be propagated everywhere for it to make sense and
# have consistency in the package tree.
fixupFor = manualPackages: qlPkg:
assert (lib.isAttrs qlPkg && !lib.isDerivation qlPkg);
let
# Make it possible to reuse generated attrs without recursing into oblivion
packages = (lib.filterAttrs (n: v: n != qlPkg.pname) manualPackages);
substituteLib = pkg:
if lib.hasAttr pkg.pname packages
then packages.${pkg.pname}
else pkg;
pkg = substituteLib qlPkg;
in pkg // { lispLibs = map substituteLib pkg.lispLibs; };
makeAttrName = str:
removeSuffix
"_"
(replaceStrings
["+" "." "/"]
["_plus_" "_dot_" "_slash_"]
str);
oldMakeWrapper = pkgs.runCommand "make-wrapper.sh" {} ''
substitute ${./old-make-wrapper.sh} $out \
--replace @shell@ ${pkgs.bash}/bin/bash
'';
# Creates a lisp wrapper with `packages` installed
#
# `packages` is a function that takes `clpkgs` - a set of lisp
# packages - as argument and returns the list of packages to be
# installed
lispWithPackagesInternal = clpkgs: packages:
# FIXME just use flattenedDeps instead
(build-asdf-system rec {
lisp = (head (lib.attrValues clpkgs)).lisp;
# See dontUnpack in build-asdf-system
src = null;
pname = baseNameOf (head (split " " lisp));
version = "with-packages";
lispLibs = packages clpkgs;
systems = [];
}).overrideAttrs(o: {
installPhase = ''
# The recent version of makeWrapper causes breakage. For more info see
# https://github.com/Uthar/nix-cl/issues/2
source ${oldMakeWrapper}
mkdir -pv $out/bin
makeWrapper \
${head (split " " o.lisp)} \
$out/bin/${baseNameOf (head (split " " o.lisp))} \
--prefix CL_SOURCE_REGISTRY : "${o.CL_SOURCE_REGISTRY}" \
--prefix ASDF_OUTPUT_TRANSLATIONS : ${concatStringsSep "::" (flattenedDeps o.lispLibs)}: \
--prefix LD_LIBRARY_PATH : "${o.LD_LIBRARY_PATH}" \
--prefix LD_LIBRARY_PATH : "${makeLibraryPath o.nativeLibs}" \
--prefix CLASSPATH : "${o.CLASSPATH}" \
--prefix CLASSPATH : "${makeSearchPath "share/java/*" o.javaLibs}" \
--prefix PATH : "${makeBinPath (o.buildInputs or [])}" \
--prefix PATH : "${makeBinPath (o.propagatedBuildInputs or [])}"
'';
});
lispWithPackages = lisp:
let
packages = lispPackagesFor lisp;
in lispWithPackagesInternal packages;
lispPackagesFor = lisp:
let
packages = commonLispPackagesFor lisp;
qlPackages = quicklispPackagesFor {
inherit lisp;
fixup = fixupFor packages;
};
in qlPackages // packages;
commonLispPackages = rec {
inherit
build-asdf-system
lispWithPackagesInternal
lispPackagesFor
lispWithPackages;
# TODO: uncomment clasp when clasp 1.0.0 is packaged
# There's got to be a better way than this...
# The problem was that with --load everywhere, some
# implementations didn't exit with 0 on compilation failure
# Maybe a handler-case in buildScript?
sbcl = "${pkgs.sbcl}/bin/sbcl --script";
ecl = "${pkgs.ecl}/bin/ecl --shell";
abcl = ''${pkgs.abcl}/bin/abcl --batch --eval "(load \"$buildScript\")"'';
ccl = ''${pkgs.ccl}/bin/ccl --batch --eval "(load \"$buildScript\")" --'';
# clasp = ''${pkgs.clasp}/bin/clasp --non-interactive --quit --load'';
# Manually defined packages shadow the ones imported from quicklisp
sbclPackages = recurseIntoAttrs (lispPackagesFor sbcl);
eclPackages = dontRecurseIntoAttrs (lispPackagesFor ecl);
abclPackages = dontRecurseIntoAttrs (lispPackagesFor abcl);
cclPackages = dontRecurseIntoAttrs (lispPackagesFor ccl);
# claspPackages = lispPackagesFor clasp;
sbclWithPackages = lispWithPackages sbcl;
eclWithPackages = lispWithPackages ecl;
abclWithPackages = lispWithPackages abcl;
cclWithPackages = lispWithPackages ccl;
# claspWithPackages = lispWithPackages clasp;
};
in commonLispPackages

155
pkgs/development/lisp-modules-new-obsolete/old-make-wrapper.sh
View file

@ -1,155 +0,0 @@
# Assert that FILE exists and is executable
#
# assertExecutable FILE
assertExecutable() {
local file="$1"
[[ -f "$file" && -x "$file" ]] || \
die "Cannot wrap '$file' because it is not an executable file"
}
# construct an executable file that wraps the actual executable
# makeWrapper EXECUTABLE OUT_PATH ARGS
# ARGS:
# --argv0 NAME : set name of executed process to NAME
# (otherwise it’s called …-wrapped)
# --set VAR VAL : add VAR with value VAL to the executable’s
# environment
# --set-default VAR VAL : like --set, but only adds VAR if not already set in
# the environment
# --unset VAR : remove VAR from the environment
# --run COMMAND : run command before the executable
# --add-flags FLAGS : add FLAGS to invocation of executable
# --prefix ENV SEP VAL : suffix/prefix ENV with VAL, separated by SEP
# --suffix
# --prefix-each ENV SEP VALS : like --prefix, but VALS is a list
# --suffix-each ENV SEP VALS : like --suffix, but VALS is a list
# --prefix-contents ENV SEP FILES : like --suffix-each, but contents of FILES
# are read first and used as VALS
# --suffix-contents
makeWrapper() {
local original="$1"
local wrapper="$2"
local params varName value command separator n fileNames
local argv0 flagsBefore flags
assertExecutable "$original"
mkdir -p "$(dirname "$wrapper")"
echo "#! @shell@ -e" > "$wrapper"
params=("$@")
for ((n = 2; n < ${#params[*]}; n += 1)); do
p="${params[$n]}"
if [[ "$p" == "--set" ]]; then
varName="${params[$((n + 1))]}"
value="${params[$((n + 2))]}"
n=$((n + 2))
echo "export $varName=${value@Q}" >> "$wrapper"
elif [[ "$p" == "--set-default" ]]; then
varName="${params[$((n + 1))]}"
value="${params[$((n + 2))]}"
n=$((n + 2))
echo "export $varName=\${$varName-${value@Q}}" >> "$wrapper"
elif [[ "$p" == "--unset" ]]; then
varName="${params[$((n + 1))]}"
n=$((n + 1))
echo "unset $varName" >> "$wrapper"
elif [[ "$p" == "--run" ]]; then
command="${params[$((n + 1))]}"
n=$((n + 1))
echo "$command" >> "$wrapper"
elif [[ ("$p" == "--suffix") || ("$p" == "--prefix") ]]; then
varName="${params[$((n + 1))]}"
separator="${params[$((n + 2))]}"
value="${params[$((n + 3))]}"
n=$((n + 3))
if test -n "$value"; then
if test "$p" = "--suffix"; then
echo "export $varName=\$$varName\${$varName:+${separator@Q}}${value@Q}" >> "$wrapper"
else
echo "export $varName=${value@Q}\${$varName:+${separator@Q}}\$$varName" >> "$wrapper"
fi
fi
elif [[ "$p" == "--prefix-each" ]]; then
varName="${params[$((n + 1))]}"
separator="${params[$((n + 2))]}"
values="${params[$((n + 3))]}"
n=$((n + 3))
for value in $values; do
echo "export $varName=${value@Q}\${$varName:+${separator@Q}}\$$varName" >> "$wrapper"
done
elif [[ "$p" == "--suffix-each" ]]; then
varName="${params[$((n + 1))]}"
separator="${params[$((n + 2))]}"
values="${params[$((n + 3))]}"
n=$((n + 3))
for value in $values; do
echo "export $varName=\$$varName\${$varName:+$separator}${value@Q}" >> "$wrapper"
done
elif [[ ("$p" == "--suffix-contents") || ("$p" == "--prefix-contents") ]]; then
varName="${params[$((n + 1))]}"
separator="${params[$((n + 2))]}"
fileNames="${params[$((n + 3))]}"
n=$((n + 3))
for fileName in $fileNames; do
contents="$(cat "$fileName")"
if test "$p" = "--suffix-contents"; then
echo "export $varName=\$$varName\${$varName:+$separator}${contents@Q}" >> "$wrapper"
else
echo "export $varName=${contents@Q}\${$varName:+$separator}\$$varName" >> "$wrapper"
fi
done
elif [[ "$p" == "--add-flags" ]]; then
flags="${params[$((n + 1))]}"
n=$((n + 1))
flagsBefore="$flagsBefore $flags"
elif [[ "$p" == "--argv0" ]]; then
argv0="${params[$((n + 1))]}"
n=$((n + 1))
else
die "makeWrapper doesn't understand the arg $p"
fi
done
echo exec ${argv0:+-a \"$argv0\"} \""$original"\" \
"$flagsBefore" '"$@"' >> "$wrapper"
chmod +x "$wrapper"
}
addSuffix() {
suffix="$1"
shift
for name in "$@"; do
echo "$name$suffix"
done
}
filterExisting() {
for fn in "$@"; do
if test -e "$fn"; then
echo "$fn"
fi
done
}
# Syntax: wrapProgram <PROGRAM> <MAKE-WRAPPER FLAGS...>
wrapProgram() {
local prog="$1"
local hidden
assertExecutable "$prog"
hidden="$(dirname "$prog")/.$(basename "$prog")"-wrapped
while [ -e "$hidden" ]; do
hidden="${hidden}_"
done
mv "$prog" "$hidden"
# Silence warning about unexpanded $0:
# shellcheck disable=SC2016
makeWrapper "$hidden" "$prog" --argv0 '$0' "${@:2}"
}

336
pkgs/development/lisp-modules-new-obsolete/packages.nix
View file

@ -1,336 +0,0 @@
{ build-asdf-system, lisp, quicklispPackagesFor, fixupFor, pkgs, ... }:
let
inherit (pkgs.lib)
head
makeLibraryPath
makeSearchPath
setAttr
hasAttr
optionals
hasSuffix
splitString
;
# Used by builds that would otherwise attempt to write into storeDir.
#
# Will run build two times, keeping all files created during the
# first run, exept the FASL's. Then using that directory tree as the
# source of the second run.
#
# E.g. cl-unicode creating .txt files during compilation
build-with-compile-into-pwd = args:
let
build = (build-asdf-system (args // { version = args.version + "-build"; }))
.overrideAttrs(o: {
buildPhase = with builtins; ''
mkdir __fasls
export LD_LIBRARY_PATH=${makeLibraryPath o.nativeLibs}:$LD_LIBRARY_PATH
export CLASSPATH=${makeSearchPath "share/java/*" o.javaLibs}:$CLASSPATH
export CL_SOURCE_REGISTRY=$CL_SOURCE_REGISTRY:$(pwd)//
export ASDF_OUTPUT_TRANSLATIONS="$(pwd):$(pwd)/__fasls:${storeDir}:${storeDir}"
${o.lisp} ${o.buildScript}
'';
installPhase = ''
mkdir -pv $out
rm -rf __fasls
cp -r * $out
'';
});
in build-asdf-system (args // {
# Patches are already applied in `build`
patches = [];
src = build;
});
# A little hacky
isJVM = hasSuffix "abcl" (head (splitString " " lisp));
# Makes it so packages imported from Quicklisp can be re-used as
# lispLibs ofpackages in this file.
ql = quicklispPackagesFor { inherit lisp; fixup = fixupFor packages; };
packages = rec {
asdf = build-with-compile-into-pwd {
pname = "asdf";
version = "3.3.5.3";
src = pkgs.fetchzip {
url = "https://gitlab.common-lisp.net/asdf/asdf/-/archive/3.3.5.3/asdf-3.3.5.3.tar.gz";
sha256 = "0aw200awhg58smmbdmz80bayzmbm1a6547gv0wmc8yv89gjqldbv";
};
systems = [ "asdf" "uiop" ];
};
uiop = asdf.overrideLispAttrs(o: {
pname = "uiop";
});
cffi = let
jna = pkgs.fetchMavenArtifact {
groupId = "net.java.dev.jna";
artifactId = "jna";
version = "5.9.0";
sha256 = "0qbis8acv04fi902qzak1mbagqaxcsv2zyp7b8y4shs5nj0cgz7a";
};
in build-asdf-system {
src = pkgs.fetchzip {
url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz";
sha256 = "17ryim4xilb1rzxydfr7595dnhqkk02lmrbkqrkvi9091shi4cj3";
};
version = "0.24.1";
pname = "cffi";
lispLibs = with ql; [
alexandria
babel
trivial-features
];
javaLibs = optionals isJVM [ jna ];
};
cffi-libffi = ql.cffi-libffi.overrideLispAttrs (o: {
src = pkgs.fetchzip {
url = "https://github.com/cffi/cffi/archive/3f842b92ef808900bf20dae92c2d74232c2f6d3a.tar.gz";
sha256 = "1jilvmbbfrmb23j07lwmkbffc6r35wnvas5s4zjc84i856ccclm2";
};
patches = [ ./patches/cffi-libffi-darwin-ffi-h.patch ];
});
cl-unicode = build-with-compile-into-pwd {
pname = "cl-unicode";
version = "0.1.6";
src = pkgs.fetchzip {
url = "https://github.com/edicl/cl-unicode/archive/refs/tags/v0.1.6.tar.gz";
sha256 = "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza";
};
systems = [ "cl-unicode" ];
lispLibs = with ql; [
cl-ppcre
flexi-streams
];
};
jzon = build-asdf-system {
src = pkgs.fetchzip {
url = "https://github.com/Zulu-Inuoe/jzon/archive/6b201d4208ac3f9721c461105b282c94139bed29.tar.gz";
sha256 = "01d4a78pjb1amx5amdb966qwwk9vblysm1li94n3g26mxy5zc2k3";
};
version = "0.0.0-20210905-6b201d4208";
pname = "jzon";
lispLibs = [
ql.closer-mop
];
systems = [ "com.inuoe.jzon" ];
};
cl-notify = build-asdf-system {
pname = "cl-notify";
version = "20080904-138ca7038";
src = pkgs.fetchzip {
url = "https://repo.or.cz/cl-notify.git/snapshot/138ca703861f4a1fbccbed557f92cf4d213668a1.tar.gz";
sha256 = "0k6ns6fzvjcbpsqgx85r4g5m25fvrdw9481i9vyabwym9q8bbqwx";
};
lispLibs = [
cffi
];
nativeLibs = [
pkgs.libnotify
];
};
cl-liballegro-nuklear = build-with-compile-into-pwd {
inherit (ql.cl-liballegro-nuklear) pname version src;
nativeBuildInputs = [ pkgs.allegro5 ];
nativeLibs = [ pkgs.allegro5 ];
lispLibs = ql.cl-liballegro-nuklear.lispLibs ++ [ ql.cl-liballegro ];
patches = [ ./patches/cl-liballegro-nuklear-missing-dll.patch ];
};
tuple = build-asdf-system {
pname = "tuple";
version = "b74bd067d";
src = pkgs.fetchzip {
url = "https://fossil.galkowski.xyz/tuple/tarball/b74bd067d4533ac0/tuple.tar.gz";
sha256 = "0dk356vkv6kwwcmc3j08x7143549m94rd66rpkzq8zkb31cg2va8";
};
};
cl-tar-file = build-asdf-system {
pname = "cl-tar-file";
version = "v0.2.1";
src = pkgs.fetchzip {
url = let
rev = "0c10bc82f14702c97a26dc25ce075b5d3a2347d1";
in "https://gitlab.common-lisp.net/cl-tar/cl-tar-file/-/archive/${rev}/cl-tar-file-${rev}.tar.gz";
sha256 = "0i8j05fkgdqy4c4pqj0c68sh4s3klpx9kc5wp73qwzrl3xqd2svy";
};
lispLibs = with ql; [
alexandria
babel
trivial-gray-streams
_40ants-doc
salza2
chipz
flexi-streams
parachute
];
systems = [ "tar-file" "tar-file/test" ];
};
cl-tar = build-asdf-system {
pname = "cl-tar";
version = "v0.2.1";
src = pkgs.fetchzip {
url = let
rev = "7c6e07a10c93d9e311f087b5f6328cddd481669a";
in "https://gitlab.common-lisp.net/cl-tar/cl-tar/-/archive/${rev}/cl-tar-${rev}.tar.gz";
sha256 = "0wp23cs3i6a89dibifiz6559la5nk58d1n17xvbxq4nrl8cqsllf";
};
lispLibs = with ql; [
alexandria
babel
local-time
split-sequence
_40ants-doc
parachute
osicat
] ++ [ cl-tar-file ];
systems = [
"tar"
"tar/common-extract"
"tar/simple-extract"
"tar/extract"
"tar/create"
"tar/docs"
"tar/test"
"tar/create-test"
"tar/extract-test"
"tar/simple-extract-test"
];
};
lessp = build-asdf-system {
pname = "lessp";
version = "0.2-f8a9e4664";
src = pkgs.fetchzip {
url = "https://github.com/facts-db/cl-lessp/archive/632217602b85b679e8d420654a0aa39e798ca3b5.tar.gz";
sha256 = "0i3ia14dzqwjpygd0zn785ff5vqnnmkn75psfpyx0ni3jr71lkq9";
};
};
rollback = build-asdf-system {
pname = "rollback";
version = "0.1-5d3f21fda";
src = pkgs.fetchzip {
url = "https://github.com/facts-db/cl-rollback/archive/5d3f21fda8f04f35c5e9d20ee3b87db767915d15.tar.gz";
sha256 = "12dpxsbm2al633y87i8p784k2dn4bbskz6sl40v9f5ljjmjqjzxf";
};
};
facts = build-asdf-system {
pname = "facts";
version = "0.1-632217602";
src = pkgs.fetchzip {
url = "https://github.com/facts-db/cl-lessp/archive/632217602b85b679e8d420654a0aa39e798ca3b5.tar.gz";
sha256 = "09z1vwzjm7hlb529jl3hcjnfd11gh128lmdg51im7ar4jv4746iw";
};
lispLibs = [ lessp rollback ] ++ [ ql.local-time ];
};
cl-fuse = build-with-compile-into-pwd {
inherit (ql.cl-fuse) pname version src lispLibs;
nativeBuildInputs = [ pkgs.fuse ];
nativeLibs = [ pkgs.fuse ];
};
cl-containers = build-asdf-system {
inherit (ql.cl-containers) pname version src;
lispLibs = ql.cl-containers.lispLibs ++ [ ql.moptilities ];
systems = [ "cl-containers" "cl-containers/with-moptilities" ];
};
swank = build-with-compile-into-pwd {
inherit (ql.swank) pname version src lispLibs;
patches = [ ./patches/swank-pure-paths.patch ];
postConfigure = ''
substituteAllInPlace swank-loader.lisp
'';
};
clx-truetype = build-asdf-system {
pname = "clx-truetype";
version = "20160825-git";
src = pkgs.fetchzip {
url = "http://beta.quicklisp.org/archive/clx-truetype/2016-08-25/clx-truetype-20160825-git.tgz";
sha256 = "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37";
};
lispLibs = with ql; [
alexandria bordeaux-threads cl-aa cl-fad cl-paths cl-paths-ttf
cl-store cl-vectors clx trivial-features zpb-ttf
];
};
mathkit = build-asdf-system {
inherit (ql.mathkit) pname version src asds lisp;
lispLibs = ql.mathkit.lispLibs ++ [ ql.sb-cga ];
};
nyxt-gtk = build-asdf-system {
inherit (ql.nyxt) pname lisp;
version = "2.2.4";
lispLibs = ql.nyxt.lispLibs ++ (with ql; [
cl-cffi-gtk cl-webkit2 mk-string-metrics
]);
src = pkgs.fetchzip {
url = "https://github.com/atlas-engineer/nyxt/archive/2.2.4.tar.gz";
sha256 = "12l7ir3q29v06jx0zng5cvlbmap7p709ka3ik6x29lw334qshm9b";
};
nativeBuildInputs = [ pkgs.makeWrapper ];
buildInputs = [
# needed for GSETTINGS_SCHEMAS_PATH
pkgs.gsettings-desktop-schemas pkgs.glib pkgs.gtk3
# needed for XDG_ICON_DIRS
pkgs.gnome.adwaita-icon-theme
];
buildScript = pkgs.writeText "build-nyxt.lisp" ''
(require :asdf)
(asdf:load-system :nyxt/gtk-application)
(sb-ext:save-lisp-and-die "nyxt" :executable t
#+sb-core-compression :compression
#+sb-core-compression t
:toplevel #'nyxt:entry-point)
'';
# Run with WEBKIT_FORCE_SANDBOX=0 if getting a runtime error in webkitgtk-2.34.4
installPhase = ql.nyxt.installPhase + ''
rm -v $out/nyxt
mkdir -p $out/bin
cp -v nyxt $out/bin
wrapProgram $out/bin/nyxt \
--prefix LD_LIBRARY_PATH : $LD_LIBRARY_PATH \
--prefix XDG_DATA_DIRS : $XDG_ICON_DIRS \
--prefix XDG_DATA_DIRS : $GSETTINGS_SCHEMAS_PATH \
--prefix GIO_EXTRA_MODULES ":" ${pkgs.dconf.lib}/lib/gio/modules/ \
--prefix GIO_EXTRA_MODULES ":" ${pkgs.glib-networking}/lib/gio/modules/
'';
};
nyxt = nyxt-gtk;
ltk = ql.ltk.overrideLispAttrs (o: {
src = pkgs.fetchzip {
url = "https://github.com/uthar/ltk/archive/f19162e76d6c7c2f51bd289b811d9ba20dd6555e.tar.gz";
sha256 = "0mzikv4abq9yqlj6dsji1wh34mjizr5prv6mvzzj29z1485fh1bj";
};
version = "f19162e76";
});
};
in packages

14
pkgs/development/lisp-modules-new-obsolete/patches/cffi-libffi-darwin-ffi-h.patch
View file

@ -1,14 +0,0 @@
--- a/libffi/libffi-types.lisp
+++ b/libffi/libffi-types.lisp
@@ -43,9 +43,6 @@
(pkg-config-cflags "libffi" :optional t)
-#+darwin
-(include "ffi/ffi.h")
-#-darwin
(include "ffi.h")
(cenum status
Diff finished. Sun Nov 13 00:23:10 2022

16
pkgs/development/lisp-modules-new-obsolete/patches/cl-freetype2-fix-grovel-includes.patch
View file

@ -1,16 +0,0 @@
--- a/src/ffi/grovel/grovel-freetype.h
+++ b/src/ffi/grovel/grovel-freetype.h
@@ -2,7 +2,7 @@
#include <ft2build.h>
#include FT_FREETYPE_H
-#include <ftsystem.h>
-#include <fttypes.h>
-#include <ftlist.h>
-#include <ftimage.h>
+#include <freetype/ftsystem.h>
+#include <freetype/fttypes.h>
+#include <freetype/ftlist.h>
+#include <freetype/ftimage.h>
Diff finished. Mon Nov 14 22:41:57 2022

17
pkgs/development/lisp-modules-new-obsolete/patches/cl-liballegro-nuklear-missing-dll.patch
View file

@ -1,17 +0,0 @@
Fix system not loading due to:
Unhandled CFFI:LOAD-FOREIGN-LIBRARY-ERROR
Unable to load foreign library (LIBALLEGRO-NUKLEAR).
Error opening shared object "/build/source/src/liballegro_nuklear.so":
/build/source/src/liballegro_nuklear.so: undefined symbol: al_draw_ellipse.
--- a/cl-liballegro-nuklear.asd
+++ b/cl-liballegro-nuklear.asd
@@ -12,7 +12,7 @@
:description "CFFI wrapper for the Nuklear IM GUI library with liballegro backend, to be used with cl-liballegro."
:author "Andrew Kravchuk <awkravchuk@gmail.com>"
:license "MIT"
- :depends-on (:cffi :cffi-libffi :trivial-features)
+ :depends-on (:cl-liballegro :cffi :cffi-libffi :trivial-features)
:pathname "src"
:serial t
:components ((:makefile "Makefile")

27
pkgs/development/lisp-modules-new-obsolete/patches/cl-sat.glucose-binary-from-PATH-if-present.patch
View file

@ -1,27 +0,0 @@
From 2040fcab5a7be2f28add46a1412bef62ac5ccf11 Mon Sep 17 00:00:00 2001
From: Maximilian Marx <mmarx@wh2.tu-dresden.de>
Date: Thu, 24 Nov 2022 20:00:33 +0100
Subject: [PATCH] Use glucose binary from PATH if present
---
src/package.lisp | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/src/package.lisp b/src/package.lisp
index b6e26ac..bdb2581 100644
--- a/src/package.lisp
+++ b/src/package.lisp
@@ -13,7 +13,9 @@
(defvar *glucose-home* (asdf:system-relative-pathname :cl-sat.glucose "glucose-syrup/"))
(defun glucose-binary (&optional (*glucose-home* *glucose-home*))
- (merge-pathnames "simp/glucose_static" *glucose-home*))
+ (if (trivial-package-manager:which "glucose")
+ "glucose"
+ (merge-pathnames "simp/glucose_static" *glucose-home*)))
(defmethod solve ((input pathname) (solver (eql :glucose)) &rest options &key debug &allow-other-keys)
(remf options :debug)
--
2.36.2

21
pkgs/development/lisp-modules-new-obsolete/patches/magicl-dont-build-fortran-twice.patch
View file

@ -1,21 +0,0 @@
--- a/magicl.asd
+++ b/magicl.asd
@@ -143,6 +143,7 @@
(shared-object (make-pathname :type #+darwin "dylib" #-darwin "so"
:name "libexpokit"
:defaults fortran-file)))
+ (unless (probe-file (nn shared-object))
(uiop:run-program
(list "gfortran" "-fPIC" "-std=legacy"
"-c"
@@ -155,7 +156,7 @@
(nn object-file)
#+darwin "-lblas"
#+darwin "-llapack"))
- (delete-file object-file))))
+ (delete-file object-file)))))
(asdf:defsystem #:magicl/ext-expokit
Diff finished. Mon Oct 10 22:03:54 2022

28
pkgs/development/lisp-modules-new-obsolete/patches/swank-pure-paths.patch
View file

@ -1,28 +0,0 @@
Prevent swank from attempting write into storeDir
--- a/swank-loader.lisp
+++ b/swank-loader.lisp
@@ -162,7 +162,7 @@
,(unique-dir-name)))
(user-homedir-pathname)))
-(defvar *fasl-directory* (default-fasl-dir)
+(defvar *fasl-directory* #P"@out@/fasl/"
"The directory where fasl files should be placed.")
(defun binary-pathname (src-pathname binary-dir)
@@ -284,12 +284,7 @@
(contrib-dir src-dir))))
(defun delete-stale-contrib-fasl-files (swank-files contrib-files fasl-dir)
- (let ((newest (reduce #'max (mapcar #'file-write-date swank-files))))
- (dolist (src contrib-files)
- (let ((fasl (binary-pathname src fasl-dir)))
- (when (and (probe-file fasl)
- (<= (file-write-date fasl) newest))
- (delete-file fasl))))))
+ (declare (ignore swank-files contrib-files fasl-dir)))
(defun compile-contribs (&key (src-dir (contrib-dir *source-directory*))
(fasl-dir (contrib-dir *fasl-directory*))
Diff finished. Sat Jan 22 23:57:27 2022

6
pkgs/development/lisp-modules-new-obsolete/ql-import.lisp
View file

@ -1,6 +0,0 @@
(require :asdf)
(pushnew (truename "./import") asdf:*central-registry*)
(asdf:load-system :org.lispbuilds.nix)
(load "./import/main.lisp")
(org.lispbuilds.nix/main::main)

239
pkgs/development/lisp-modules-new-obsolete/ql.nix
View file

@ -1,239 +0,0 @@
{ pkgs, build-asdf-system, fixup ? pkgs.lib.id, ... }:
with pkgs;
with lib;
with lib.lists;
with lib.strings;
let
# FIXME: automatically add nativeLibs based on conditions signalled
# Try to keep this list sorted
extras = {
cffi-libffi = pkg: {
nativeBuildInputs = [ libffi ];
nativeLibs = [ libffi ];
};
"cl+ssl" = pkg: {
nativeLibs = [ openssl_1_1 ];
};
"cl-ana.hdf-cffi" = pkg: {
nativeBuildInputs = [ pkgs.hdf5 ];
nativeLibs = [ pkgs.hdf5 ];
NIX_LDFLAGS = [ "-lhdf5" ];
};
cl-async-ssl = pkg: {
nativeLibs = [ openssl_1_1 ];
};
cl-cffi-gtk-glib = pkg: {
nativeLibs = [ glib ];
};
cl-cffi-gtk-cairo = pkg: {
nativeLibs = [ cairo ];
};
cl-cffi-gtk-gdk = pkg: {
nativeLibs = [ gtk3 ];
};
cl-cffi-gtk-gdk-pixbuf = pkg: {
nativeLibs = [ gdk-pixbuf ];
};
cl-cffi-gtk-pango = pkg: {
nativeLibs = [ pango ];
};
cl-cairo2 = pkg: {
nativeLibs = [ cairo ];
};
cl-cairo2-xlib = pkg: {
nativeLibs = [ gtk2-x11 ];
};
cl-devil = pkg: {
nativeBuildInputs = [ pkgs.libdevil ];
nativeLibs = [ pkgs.libdevil ];
};
cl-freeimage = pkg: {
nativeLibs = [ freeimage ];
};
cl-freetype2 = pkg: {
nativeLibs = [ freetype ];
nativeBuildInputs = [ freetype ];
patches = [ ./patches/cl-freetype2-fix-grovel-includes.patch ];
};
cl-glfw = pkg: {
nativeLibs = [ glfw ];
};
cl-glfw-opengl-core = pkg: {
nativeLibs = [ libGL ];
};
cl-glfw3 = pkg: {
nativeLibs = [ glfw ];
};
cl-glu = pkg: {
nativeLibs = [ libGLU ];
};
cl-glut = pkg: {
nativeLibs = [ freeglut ];
};
cl-gobject-introspection = pkg: {
nativeLibs = [ glib gobject-introspection ];
};
cl-gtk2-gdk = pkg: {
nativeLibs = [ gtk2-x11 ];
};
cl-gtk2-glib = pkg: {
nativeLibs = [ glib ];
};
cl-gtk2-pango = pkg: {
nativeLibs = [ pango ];
};
cl-liballegro = pkg: {
# build doesnt fail without this, but fails on runtime
# weird...
nativeLibs = [ allegro5 ];
};
cl-libuv = pkg: {
nativeBuildInputs = [ libuv ];
nativeLibs = [ libuv ];
};
cl-libxml2 = pkg: {
nativeLibs = [ pkgs.libxml2 ];
};
cl-libyaml = pkg: {
nativeLibs = [ pkgs.libyaml ];
};
cl-mysql = pkg: {
nativeLibs = [ mariadb.client ];
};
cl-ode = pkg: {
nativeLibs = let
ode' = ode.overrideAttrs (o: {
configureFlags = [
"--enable-shared"
"--enable-double-precision"
];
});
in [ ode' ];
};
cl-opengl = pkg: {
nativeLibs = [ libGL ];
};
cl-pango = pkg: {
nativeLibs = [ pango ];
};
cl-rabbit = pkg: {
nativeBuildInputs = [ rabbitmq-c ];
nativeLibs = [ rabbitmq-c ];
};
cl-rdkafka = pkg: {
nativeBuildInputs = [ rdkafka ];
nativeLibs = [ rdkafka ];
};
cl-readline = pkg: {
nativeLibs = [ pkgs.readline ];
};
cl-rsvg2 = pkg: {
nativeLibs = [ librsvg ];
};
"cl-sat.glucose" = pkg: {
propagatedBuildInputs = [ pkgs.glucose ];
patches = [ ./patches/cl-sat.glucose-binary-from-PATH-if-present.patch ];
};
"cl-sat.minisat" = pkg: {
propagatedBuildInputs = [ pkgs.minisat ];
};
cl-webkit2 = pkg: {
nativeLibs = [ webkitgtk ];
};
classimp = pkg: {
nativeLibs = [ assimp ];
meta.broken = true; # Requires assimp ≤ 5.0.x.
};
clsql-postgresql = pkg: {
nativeLibs = [ postgresql.lib ];
};
clsql-sqlite3 = pkg: {
nativeLibs = [ sqlite ];
};
dbd-mysql = pkg: {
nativeLibs = [ mariadb.client ];
};
gsll = pkg: {
nativeBuildInputs = [ pkgs.gsl ];
nativeLibs = [ pkgs.gsl ];
};
iolib = pkg: {
nativeBuildInputs = [ libfixposix ];
nativeLibs = [ libfixposix ];
systems = [ "iolib" "iolib/os" "iolib/pathnames" ];
};
lev = pkg: {
nativeLibs = [ libev ];
};
lispbuilder-sdl-cffi = pkg: {
nativeLibs = [ SDL ];
};
lla = pkg: {
nativeLibs = [ openblas ];
};
mssql = pkg: {
nativeLibs = [ freetds ];
};
osicat = pkg: {
LD_LIBRARY_PATH = "${pkg}/posix/";
};
png = pkg: {
nativeBuildInputs = [ pkgs.libpng ];
nativeLibs = [ pkgs.libpng ];
};
pzmq = pkg: {
nativeBuildInputs = [ pkgs.zeromq ];
nativeLibs = [ pkgs.zeromq ];
};
pzmq-compat = pkg: {
nativeBuildInputs = [ pkgs.zeromq ];
nativeLibs = [ pkgs.zeromq ];
};
pzmq-examples = pkg: {
nativeBuildInputs = [ pkgs.zeromq ];
nativeLibs = [ pkgs.zeromq ];
};
pzmq-test = pkg: {
nativeBuildInputs = [ pkgs.zeromq ];
nativeLibs = [ pkgs.zeromq ];
};
sdl2 = pkg: {
nativeLibs = [ SDL2 ];
};
sqlite = pkg: {
nativeLibs = [ sqlite ];
};
trivial-package-manager = pkg: {
propagatedBuildInputs = [ pkgs.which ];
};
trivial-ssh-libssh2 = pkg: {
nativeLibs = [ libssh2 ];
};
zmq = pkg: {
nativeBuildInputs = [ pkgs.zeromq ];
nativeLibs = [ pkgs.zeromq ];
};
};
qlpkgs =
lib.optionalAttrs (builtins.pathExists ./imported.nix)
(import ./imported.nix { inherit (pkgs) runCommand fetchzip; pkgs = builtQlpkgs; });
builtQlpkgs = mapAttrs (n: v: build v) qlpkgs;
build = pkg:
let
builtPkg = build-asdf-system pkg;
withExtras = pkg //
(optionalAttrs
(hasAttr pkg.pname extras)
(extras.${pkg.pname} builtPkg));
fixedUp = fixup withExtras;
in build-asdf-system fixedUp;
in builtQlpkgs

34
pkgs/development/lisp-modules-new-obsolete/readme.md
View file

@ -1,34 +0,0 @@
# lisp-modules
Utilities for packaging ASDF systems using Nix.
## Quick start
#### Build an ASDF system:
```
nix-build ./examples/bordeaux-threads.nix
ls result/src
```
#### Build an `sbclWithPackages`:
```
nix-build ./examples/sbcl-with-bt.nix
result/bin/sbcl
```
#### Re-import Quicklisp packages:
```
nix-shell --run 'sbcl --script ql-import.lisp'
```
#### Test build of packages
```
(cd test; sbcl --script test.lisp ccl)
```
## Documentation
See `doc` directory.

7
pkgs/development/lisp-modules-new-obsolete/shell.nix
View file

@ -1,7 +0,0 @@
with import ../../../default.nix {};
mkShell {
nativeBuildInputs = [
(lispPackages_new.sbclWithPackages
(ps: with ps; [ alexandria str dexador cl-ppcre sqlite arrow-macros jzon ]))
];
}

395
pkgs/development/lisp-modules-new-obsolete/test/lispPackagesToTest.txt
View file

@ -1,395 +0,0 @@
_1am
_3bmd
_3bmd-ext-code-blocks
access
acclimation
agutil
alexandria
anaphora
arnesi
array-operations
array-utils
arrows
asdf
asdf-package-system
asdf-system-connections
babel
binomial-heap
binpack
blackbird
bordeaux-threads
buildnode
buildnode-xhtml
calispel
cffi
cffi-grovel
cffi-toolchain
cffi-uffi-compat
chanl
check-it
chipz
chunga
circular-streams
cl-aa
cl-annot
cl-anonfun
cl-ansi-text
cl-async
cl-async-base
cl-async-repl
cl-async-ssl
cl-async-util
cl-base64
cl-cffi-gtk
cl-cffi-gtk-cairo
cl-cffi-gtk-gdk
cl-cffi-gtk-gdk-pixbuf
cl-cffi-gtk-gio
cl-cffi-gtk-glib
cl-cffi-gtk-gobject
cl-cffi-gtk-pango
cl-change-case
cl-cli
cl-colors
cl-colors2
cl-containers
cl-cookie
cl-css
cl-csv
cl-cuda
cl-custom-hash-table
cl-dbi
cl-difflib
cl-digraph
cl-dot
cl-emb
cl-environments
cl-fad
cl-form-types
cl-fuse
cl-fuse-meta-fs
cl-fuzz
cl-geometry
cl-gobject-introspection
cl-heap
cl-hooks
cl-html-diff
cl-html-parse
cl-html5-parser
cl-interpol
cl-jpeg
cl-json
cl-l10n
cl-l10n-cldr
cl-libuv
cl-locale
cl-markup
cl-mustache
cl-mysql
cl-num-utils
cl-paths
cl-paths-ttf
cl-pattern
cl-pdf
cl-postgres
cl-postgres_plus_local-time
cl-postgres_slash_tests
cl-ppcre
cl-ppcre-template
cl-ppcre-test
cl-ppcre-unicode
cl-prevalence
cl-protobufs
cl-qprint
cl-qrencode
cl-reexport
cl-shellwords
cl-slice
cl-smt-lib
cl-smtp
cl-speedy-queue
cl-store
cl-svg
cl-syntax
cl-syntax-annot
cl-syntax-anonfun
cl-syntax-markup
cl-syslog
cl-test-more
cl-typesetting
cl-unicode
cl-unification
cl-utilities
cl-vectors
cl-webkit2
cl-who
cl-xmlspam
cl_plus_ssl
clack
clack-socket
classowary
clfswm
closer-mop
closure-common
closure-html
clsql
clsql-postgresql
clsql-postgresql-socket
clsql-sqlite3
clsql-uffi
clss
cluffer
clump
clump-2-3-tree
clump-binary-tree
clunit
clunit2
clx
clx-truetype
collectors
colorize
command-line-arguments
css-lite
css-selectors
css-selectors-simple-tree
css-selectors-stp
cxml
cxml-stp
cxml_slash_test
data-table
dbd-mysql
dbd-postgres
dbd-sqlite3
dbi
dbi-test
dbus
defclass-std
dexador
dissect
djula
do-urlencode
documentation-utils
drakma
eager-future2
enchant
esrap
esrap-peg
external-program
fare-csv
fare-mop
fare-quasiquote
fare-quasiquote-extras
fare-quasiquote-optima
fare-quasiquote-readtable
fare-utils
fast-http
fast-io
fiasco
file-attributes
fiveam
flexi-streams
float-features
flow
fn
form-fiddle
fset
generic-cl
generic-cl_dot_arithmetic
generic-cl_dot_collector
generic-cl_dot_comparison
generic-cl_dot_container
generic-cl_dot_internal
generic-cl_dot_iterator
generic-cl_dot_lazy-seq
generic-cl_dot_map
generic-cl_dot_math
generic-cl_dot_object
generic-cl_dot_sequence
generic-cl_dot_set
gettext
global-vars
glsl-docs
glsl-spec
glsl-symbols
heap
html-encode
http-body
hu_dot_dwim_dot_asdf
hu_dot_dwim_dot_common
hu_dot_dwim_dot_common-lisp
hu_dot_dwim_dot_def
hu_dot_dwim_dot_def_plus_swank
hu_dot_dwim_dot_defclass-star
hu_dot_dwim_dot_stefil
hu_dot_dwim_dot_stefil_plus_hu_dot_dwim_dot_def
hu_dot_dwim_dot_stefil_plus_hu_dot_dwim_dot_def_plus_swank
hu_dot_dwim_dot_stefil_plus_swank
hunchensocket
hunchentoot
idna
ieee-floats
inferior-shell
introspect-environment
iolib
iolib_dot_asdf
iolib_dot_base
iolib_dot_common-lisp
iolib_dot_conf
ironclad
iterate
jonathan
jpl-queues
jpl-util
jsown
kmrcl
lack
lack-component
lack-middleware-backtrace
lack-util
lambda-fiddle
legit
let-plus
lev
lfarm-client
lfarm-common
lfarm-server
lfarm-ssl
lift
lisp-binary
lisp-namespace
lisp-unit
lisp-unit2
lla
local-time
log4cl
lparallel
lquery
marshal
md5
metabang-bind
metatilities-base
mgl
mgl-mat
mgl-pax
minheap
misc-extensions
mk-string-metrics
mmap
moptilities
more-conditions
mt19937
named-readtables
nbd
net-telent-date
net_dot_didierverna_dot_asdf-flv
nibbles
nyxt
optima
osicat
parachute
parenscript
parse-declarations-1_dot_0
parse-float
parse-number
parseq
parser-combinators
parser_dot_common-rules
pcall
pcall-queue
physical-quantities
plump
postmodern
proc-parse
prove
prove-asdf
ptester
puri
pythonic-string-reader
quasiquote-2_dot_0
query-fs
quri
rfc2388
rove
rt
s-sql
s-sql_slash_tests
s-sysdeps
s-xml
salza2
serapeum
simple-date
simple-date-time
simple-date_slash_postgres-glue
simple-inferiors
simple-tasks
slynk
smart-buffer
smug
spinneret
split-sequence
sqlite
static-dispatch
static-vectors
stefil
str
string-case
stumpwm
swank
swap-bytes
sycamore
symbol-munger
trees
trivia
trivia_dot_balland2006
trivia_dot_level0
trivia_dot_level1
trivia_dot_level2
trivia_dot_quasiquote
trivia_dot_trivial
trivial-arguments
trivial-backtrace
trivial-clipboard
trivial-cltl2
trivial-features
trivial-file-size
trivial-garbage
trivial-gray-streams
trivial-indent
trivial-macroexpand-all
trivial-main-thread
trivial-mimes
trivial-package-local-nicknames
trivial-shell
trivial-types
trivial-utf-8
trivial-with-current-source-form
type-i
uax-15
uffi
uiop
unit-test
unix-options
unix-opts
usocket
usocket-server
utilities_dot_print-items
utilities_dot_print-tree
uuid
varjo
vas-string-metrics
vecto
vom
wild-package-inferred-system
woo
wookie
xembed
xkeyboard
xml_dot_location
xmls
xpath
xpath_slash_test
xsubseq
yacc
yason
zpb-ttf
zpng

94
pkgs/development/lisp-modules-new-obsolete/test/test.lisp
View file

@ -1,94 +0,0 @@
#!/usr/bin/env -S sbcl --script
(require :uiop)
;; prevent glibc hell
(setf (uiop:getenv "LD_LIBRARY_PATH") "")
(defparameter packages (uiop:read-file-lines "./lispPackagesToTest.txt"))
(defparameter lisp (or (cadr sb-ext:*posix-argv*) "sbcl"))
(defparameter nix-build "nix-build -E 'with import ../../../../default.nix {}; lispPackages_new.~aPackages.~a'")
(defparameter cpu-count
(length
(remove-if-not
(lambda (line)
(uiop:string-prefix-p "processor" line))
(uiop:read-file-lines "/proc/cpuinfo"))))
(defparameter sem (sb-thread:make-semaphore :count cpu-count))
(defparameter statuses (make-hash-table :synchronized t))
(defparameter log-lock (sb-thread:make-mutex))
(format *error-output* "Testing ~a on ~a cores~%" lisp cpu-count)
(defun clear-line ()
(write-char #\Return *error-output*)
(write-char #\Escape *error-output*)
(write-char #\[ *error-output*)
(write-char #\K *error-output*))
(declaim (type fixnum errors))
(defglobal errors 0)
(defmacro when-let (bindings &rest body)
(reduce
(lambda (expansion form)
(destructuring-bind (var test) form
(let ((testsym (gensym (symbol-name var))))
`(let ((,testsym ,test))
(when ,testsym
(let ((,var ,testsym))
,expansion))))))
(reverse bindings)
:initial-value `(progn ,@body)))
(dolist (pkg packages)
(sb-thread:wait-on-semaphore sem)
(sb-thread:make-thread
(lambda ()
(handler-case
(unwind-protect
(multiple-value-bind (out err code)
(uiop:run-program
(format nil nix-build lisp pkg)
:error-output '(:string :stripped t)
:ignore-error-status t)
(declare (ignorable err))
(setf (gethash pkg statuses) code)
(when-let ((pos (search "LOAD-FOREIGN-LIBRARY-ERROR" err :test #'string=))
(lines (uiop:split-string (subseq err pos) :separator '(#\Newline))))
(setf (gethash pkg statuses)
(fourth lines)))
(sb-thread:with-mutex (log-lock)
(clear-line)
(format *error-output* "[~a/~a] ~[OK~:;ERROR~] ~a~[~:;~%~]"
(hash-table-count statuses)
(length packages)
code
pkg
code)
(force-output *error-output*))
(unless (zerop code)
(sb-ext:atomic-incf errors)))
(sb-thread:signal-semaphore sem))
(error (e)
(format t "~a~%" e)
(sb-ext:quit :recklessly-p t :unix-status 1))))))
(sb-thread:wait-on-semaphore sem :n cpu-count)
(format t "~%Done (~a/~a)."
(- (length packages) errors)
(length packages))
(when (plusp errors)
(format t "~%~%~a Errors: " errors)
(maphash (lambda (k v)
(unless (and (numberp v) (zerop v))
(format t "~% ~a: ~a" k v)))
statuses))

30
pkgs/development/lisp-modules-obsolete/README.txt
View file

@ -1,30 +0,0 @@
Want to add a package? There are 3 simple steps!
1. Add the needed system names to quicklisp-to-nix-systems.txt.
2. cd <path to quicklisp-to-nix-systems.txt> ; nix-shell --pure --run 'quicklisp-to-nix .'
You might want to specify also the --cacheSystemInfoDir and --cacheFaslDir
parameters to preserve some data between runs. For example, it is very
useful when you add new packages with native dependencies and fail to
specify the native dependencies correctly the first time.
(Might be nice to ensure the cache directories exist)
3. Add native libraries and whatever else is needed to quicklisp-to-nix-overrides.nix.
If libraries are needed during package analysis then add them to shell.nix, too.
4. Sometimes there are problems with loading implementation-provided systems.
In this case you might need to add more systems in the implementation's (so
SBCL's) entry into *implementation-systems* in quicklisp-to-nix/system-info.lisp
To update to a more recent quicklisp dist modify
lispPackages.quicklisp to have a more recent distinfo.
quicklisp-to-nix-system-info is responsible for installing a quicklisp
package into an isolated environment and figuring out which packages
are required by that system. It also extracts other information that
is readily available once the system is loaded. The information
produced by this program is fed into quicklisp-to-nix. You usually
don't need to run this program unless you're trying to understand why
quicklisp-to-nix failed to handle a system. The technique used by
quicklisp-to-nix-system-info is described in its source.
quicklisp-to-nix is responsible for reading
quicklisp-to-nix-systems.txt, running quicklisp-to-nix-system-info,
and generating the nix packages associated with the closure of
quicklisp systems.

38
pkgs/development/lisp-modules-obsolete/asdf/2.26.nix
View file

@ -1,38 +0,0 @@
{ lib, stdenv, fetchurl, texinfo, texLive, perl }:
stdenv.mkDerivation rec {
pname = "asdf";
version = "2.26";
src = fetchurl {
url = "http://common-lisp.net/project/asdf/archives/asdf-${version}.tar.gz";
sha256 = "sha256-tuUuIlZcS+a0izXeJl3Ckp+/PYAWkZ0+Cw7blwkh9+M=";
};
strictDeps = true;
nativeBuildInputs = [
texinfo
texLive
perl
];
buildPhase = ''
make asdf.lisp
mkdir build
ln -s ../asdf.lisp build
'';
installPhase = ''
mkdir -p "$out"/lib/common-lisp/asdf/
mkdir -p "$out"/share/doc/asdf/
cp -r ./* "$out"/lib/common-lisp/asdf/
cp -r doc/* "$out"/share/doc/asdf/
ln -s "$out"/lib/common-lisp/{asdf/uiop,uiop}
'';
meta = with lib; {
description = "Standard software-system definition library for Common Lisp";
license = licenses.mit;
maintainers = with maintainers; [ raskin ];
platforms = platforms.linux;
};
}

37
pkgs/development/lisp-modules-obsolete/asdf/3.1.nix
View file

@ -1,37 +0,0 @@
{ lib, stdenv, fetchurl, texinfo, texLive, perl }:
stdenv.mkDerivation rec {
pname = "asdf";
version = "3.1.7";
src = fetchurl {
url = "http://common-lisp.net/project/asdf/archives/asdf-${version}.tar.gz";
sha256 = "sha256-+P+FLM1mr2KRdj7bfhWq4ync86bJS/uE0Jm/E/e4HL0=";
};
strictDeps = true;
nativeBuildInputs = [
texinfo
texLive
perl
];
buildPhase = ''
make build/asdf.lisp
make -C doc asdf.info asdf.html
'';
installPhase = ''
mkdir -p "$out"/lib/common-lisp/asdf/
mkdir -p "$out"/share/doc/asdf/
cp -r ./* "$out"/lib/common-lisp/asdf/
cp -r doc/* "$out"/share/doc/asdf/
ln -s "$out"/lib/common-lisp/{asdf/uiop,uiop}
'';
meta = with lib; {
description = "Standard software-system definition library for Common Lisp";
license = licenses.mit;
maintainers = with maintainers; [ raskin ];
platforms = platforms.unix;
};
}

37
pkgs/development/lisp-modules-obsolete/asdf/default.nix
View file

@ -1,37 +0,0 @@
{ lib, stdenv, fetchurl, texinfo, texLive, perl }:
stdenv.mkDerivation rec {
pname = "asdf";
version = "3.3.4";
src = fetchurl {
url = "http://common-lisp.net/project/asdf/archives/asdf-${version}.tar.gz";
sha256 = "sha256-/k7cmN0ymZUgpP4K+IWfhq85TkzfPjTR4QdUgV9n1x4=";
};
strictDeps = true;
nativeBuildInputs = [
texinfo
texLive
perl
];
buildPhase = ''
make build/asdf.lisp
make -C doc asdf.info asdf.html
'';
installPhase = ''
mkdir -p "$out"/lib/common-lisp/asdf/
mkdir -p "$out"/share/doc/asdf/
cp -r ./* "$out"/lib/common-lisp/asdf/
cp -r doc/* "$out"/share/doc/asdf/
ln -s "$out"/lib/common-lisp/{asdf/uiop,uiop}
'';
meta = with lib; {
description = "Standard software-system definition library for Common Lisp";
license = licenses.mit;
maintainers = with maintainers; [ raskin ];
platforms = platforms.unix;
};
}

67
pkgs/development/lisp-modules-obsolete/clwrapper/build-with-lisp.sh
View file

@ -1,67 +0,0 @@
#! /bin/sh
# Part of NixPkgs package collection
# This script can be used at your option under the same license as NixPkgs or
# under MIT/X11 license
lisp="$1"
systems="$2"
target="$3"
code="$4"
NIX_LISP_SKIP_CODE=1 NIX_LISP_COMMAND="$lisp" source "$(dirname "$0")/cl-wrapper.sh"
NIX_LISP_BUILD_CODE=
case "$NIX_LISP" in
sbcl)
NIX_LISP_BUILD_CODE="(progn
(let*
((old-fn (symbol-function 'sb-alien::dlopen-or-lose )))
(sb-ext:with-unlocked-packages (:sb-sys :sb-alien)
(defun sb-alien::dlopen-or-lose (&rest args)
(or
(ignore-errors (progn (apply old-fn args)))
(and
args
(loop
with try = nil
with obj = (first args)
with original-namestring = (sb-alien::shared-object-namestring obj)
for path in (list $(echo "$NIX_LISP_LD_LIBRARY_PATH" | sed -e 's/:/" "/g; s/^/"/; s/$/"/'))
for target := (format nil \"~a/~a\" path original-namestring)
when (ignore-errors
(progn
(setf (sb-alien::shared-object-namestring obj) target)
(setf try (apply old-fn args))
t)) do
(progn (return try))
finally (progn (setf (sb-alien::shared-object-namestring obj) original-namestring)
(return (apply old-fn args)))
)
)
)
)
)
)
(sb-ext:save-lisp-and-die \"$target\"
:toplevel (lambda ()
(setf common-lisp:*standard-input* (sb-sys::make-fd-stream 0 :input t :buffering :line))
(setf common-lisp:*standard-output* (sb-sys::make-fd-stream 1 :output t :buffering :line))
(setf uiop/image:*command-line-arguments* (cdr sb-ext:*posix-argv*))
$code)
:executable t :save-runtime-options t :purify t))"
systems=":sb-posix $systems"
;;
ecl)
NIX_LISP_BUILD_CODE="()"
;;
clisp)
NIX_LISP_BUILD_CODE="(ext:saveinitmem \"$target\" :norc t :init-function (lambda () $code (ext:bye)) :script nil :executable 0)"
;;
esac
"$lisp" \
"$NIX_LISP_EXEC_CODE" "(load \"$NIX_LISP_ASDF/lib/common-lisp/asdf/build/asdf.lisp\")" \
"$NIX_LISP_EXEC_CODE" "(mapcar 'asdf:load-system (list $systems))" \
"$NIX_LISP_EXEC_CODE" "$NIX_LISP_BUILD_CODE" \
"$NIX_LISP_EXEC_CODE" "(quit)"

134
pkgs/development/lisp-modules-obsolete/clwrapper/cl-wrapper.sh
View file

@ -1,134 +0,0 @@
#!@bash@/bin/bash
# Part of NixPkgs package collection
# This script can be used at your option under the same license as NixPkgs or
# under MIT/X11 license
eval "$NIX_LISP_PREHOOK"
NIX_LISP_COMMAND="$1"
shift
if [ -z "$NIX_LISP" ]; then
while [ -h "${NIX_LISP_COMMAND}" ]; do
NIX_LISP_COMMAND="$(readlink -n "${NIX_LISP_COMMAND}")"
done
NIX_LISP="${NIX_LISP_COMMAND##*/}"
fi
export NIX_LISP NIX_LISP_LOAD_FILE NIX_LISP_EXEC_CODE NIX_LISP_COMMAND NIX_LISP_FINAL_PARAMETERS
test -n "$NIX_LISP_LD_LIBRARY_PATH" &&
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH${LD_LIBRARY_PATH:+:}$NIX_LISP_LD_LIBRARY_PATH"
declare -a NIX_LISP_FINAL_PARAMETERS;
case "$NIX_LISP" in
sbcl)
NIX_LISP_LOAD_FILE="--load"
NIX_LISP_EXEC_CODE="--eval"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG='--non-interactive'
NIX_LISP_FINAL_PARAMETERS=
NIX_LISP_FASL_TYPE="fasl"
;;
ecl)
NIX_LISP_LOAD_FILE="-load"
NIX_LISP_EXEC_CODE="-eval"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG='--nodebug'
NIX_LISP_FINAL_PARAMETERS=
NIX_LISP_FASL_TYPE="fas"
;;
clisp)
NIX_LISP_LOAD_FILE="-c -l"
NIX_LISP_EXEC_CODE="-x"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG='-on-error exit'
NIX_LISP_FINAL_PARAMETERS="-repl"
NIX_LISP_FASL_TYPE="fas"
;;
lx86cl64)
NIX_LISP_LOAD_FILE="-l"
NIX_LISP_EXEC_CODE="-e"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG='-b'
NIX_LISP_FINAL_PARAMETERS=
NIX_LISP_FASL_TYPE="lx64fsl"
;;
lx86cl)
NIX_LISP_LOAD_FILE="-l"
NIX_LISP_EXEC_CODE="-e"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG='-b'
NIX_LISP_FINAL_PARAMETERS=
NIX_LISP_FASL_TYPE="lx32fsl"
;;
abcl)
NIX_LISP_LOAD_FILE="--load"
NIX_LISP_EXEC_CODE="--eval"
NIX_LISP_QUIT="(quit)"
NIX_LISP_NODEBUG=''
NIX_LISP_FINAL_PARAMETERS=
NIX_LISP_FASL_TYPE="abcl"
;;
esac
NIX_LISP_ASDF_REGISTRY_CODE="
(progn
(setf asdf:*source-registry-parameter*
'(:source-registry
$(for p in $NIX_LISP_ASDF_PATHS; do
echo "(:tree \"$p\")"
done)
:inherit-configuration))
(asdf:initialize-source-registry)
)
"
NIX_LISP_ASDF="${NIX_LISP_ASDF:-@out@}"
nix_lisp_run_single_form(){
NIX_LISP_FINAL_PARAMETERS=("$NIX_LISP_EXEC_CODE" "$1"
"$NIX_LISP_EXEC_CODE" "$NIX_LISP_QUIT" $NIX_LISP_NODEBUG)
}
nix_lisp_build_system(){
NIX_LISP_FINAL_PARAMETERS=(
"$NIX_LISP_EXEC_CODE" "(progn
(asdf:load-system :$1)
(loop for s in (list $(for i in $3; do echo ":$i"; done)) do (asdf:load-system s)))"
"$NIX_LISP_EXEC_CODE" "(progn
(setf (asdf/system:component-entry-point (asdf:find-system :$1)) ${2:-nil})
#+cffi(setf cffi:*foreign-library-directories*
(cffi::explode-path-environment-variable \"NIX_LISP_LD_LIBRARY_PATH\"))
#+sbcl(loop
with libpath := (uiop:split-string (uiop:getenv \"NIX_LISP_LD_LIBRARY_PATH\")
:separator \":\")
for l in sb-alien::*shared-objects*
for ns := (sb-alien::shared-object-namestring l)
do (format *error-output* \"Searching alien object ~s in ~s~%\"
ns libpath)
do (and (> (length ns) 0) (not (equal (elt ns 0) \"/\"))
(let*
((prefix (find-if (lambda (s) (probe-file (format nil \"~a/~a\" s ns))) libpath))
(fullpath (and prefix (format nil \"~a/~a\" prefix ns))))
(when fullpath
(format *error-output* \"Found: ~s~%\" fullpath)
(setf
(sb-alien::shared-object-namestring l) fullpath
(sb-alien::shared-object-pathname l) (probe-file fullpath)))))
)
$4
(asdf:perform (quote asdf:program-op) :$1)
)")
}
eval "$NIX_LISP_PRELAUNCH_HOOK"
if [ -z "$NIX_LISP_SKIP_CODE" ]; then
"$NIX_LISP_COMMAND" $NIX_LISP_EARLY_OPTIONS \
$NIX_LISP_EXEC_CODE "${NIX_LISP_ASDF_LOAD:-"(load \"$NIX_LISP_ASDF/lib/common-lisp/asdf/build/asdf.$NIX_LISP_FASL_TYPE\")"}" \
$NIX_LISP_EXEC_CODE "$NIX_LISP_ASDF_REGISTRY_CODE" \
${NIX_LISP_FINAL_PARAMETERS[*]:+"${NIX_LISP_FINAL_PARAMETERS[@]}"} \
"$@"
fi

3
pkgs/development/lisp-modules-obsolete/clwrapper/common-lisp.sh
View file

@ -1,3 +0,0 @@
#!@bash@/bin/bash
source "@out@"/bin/cl-wrapper.sh "${NIX_LISP_COMMAND:-$(@ls@ "@lisp@/bin"/* | @head@ -n 1)}" "$@"

57
pkgs/development/lisp-modules-obsolete/clwrapper/default.nix
View file

@ -1,57 +0,0 @@
{lib, stdenv, asdf, which, bash, lisp ? null}:
stdenv.mkDerivation {
name = "cl-wrapper-script";
buildPhase="";
installPhase=''
mkdir -p "$out"/bin
export head="$(which head)"
export ls="$(which ls)"
substituteAll ${./common-lisp.sh} "$out"/bin/common-lisp.sh
substituteAll "${./build-with-lisp.sh}" "$out/bin/build-with-lisp.sh"
substituteAll "${./cl-wrapper.sh}" "$out/bin/cl-wrapper.sh"
patchShebangs "$out/bin"
chmod a+x "$out"/bin/*
substituteAll "${./setup-hook.sh}" "setup-hook-parsed"
addEnvHooks(){ true; };
source setup-hook-parsed
setLisp "${lisp}"
echo "$NIX_LISP"
mkdir -p "$out/lib/common-lisp/"
cp -r "${asdf}/lib/common-lisp"/* "$out/lib/common-lisp/"
chmod u+rw -R "$out/lib/common-lisp/"
NIX_LISP_PRELAUNCH_HOOK='
NIX_LISP_FASL_TYPE=lisp
nix_lisp_run_single_form "(progn
(uiop/lisp-build:compile-file* \"'"$out"'/lib/common-lisp/asdf/build/asdf.lisp\")
(asdf:load-system :uiop :force :all)
(asdf:load-system :asdf :force :all)
(ignore-errors (asdf:load-system :uiop/version :force :all))
)"' \
"$out/bin/common-lisp.sh"
'';
buildInputs = [which];
inherit asdf lisp bash;
stdenv_shell = stdenv.shell;
setupHook = ./setup-hook.sh;
dontUnpack = true;
ASDF_OUTPUT_TRANSLATIONS="${builtins.storeDir}/:${builtins.storeDir}";
passthru = {
inherit lisp;
};
meta = {
description = "Script used to wrap Common Lisp implementations";
maintainers = [lib.maintainers.raskin];
};
}

39
pkgs/development/lisp-modules-obsolete/clwrapper/setup-hook.sh
View file

@ -1,39 +0,0 @@
NIX_LISP_ASDF="@out@"
CL_SOURCE_REGISTRY="${CL_SOURCE_REGISTRY:+$CL_SOURCE_REGISTRY:}@out@/lib/common-lisp/asdf/"
addASDFPaths () {
for j in "$1"/lib/common-lisp-settings/*-path-config.sh; do
source "$j"
done
}
setLisp () {
if [ -z "${NIX_LISP_COMMAND:-}" ]; then
for j in "$1"/bin/*; do
case "$(basename "$j")" in
sbcl) NIX_LISP_COMMAND="$j" ;;
ecl) NIX_LISP_COMMAND="$j" ;;
clisp) NIX_LISP_COMMAND="$j" ;;
lx86cl) NIX_LISP_COMMAND="$j" ;;
lx86cl64) NIX_LISP_COMMAND="$j" ;;
esac
done
fi
if [ -n "${NIX_LISP_COMMAND:-}" ] && [ -z "${NIX_LISP:-}" ]; then
NIX_LISP="${NIX_LISP_COMMAND##*/}"
fi
}
collectNixLispLDLP () {
if echo "$1/lib"/lib*.{so,dylib}* | grep . > /dev/null; then
export NIX_LISP_LD_LIBRARY_PATH="${NIX_LISP_LD_LIBRARY_PATH-}${NIX_LISP_LD_LIBRARY_PATH:+:}$1/lib"
fi
}
export NIX_LISP_COMMAND NIX_LISP CL_SOURCE_REGISTRY NIX_LISP_ASDF
addEnvHooks "$targetOffset" addASDFPaths setLisp collectNixLispLDLP
mkdir -p "$HOME"/.cache/common-lisp || HOME="$TMP/.temp-${USER:-nixbld}-home"
mkdir -p "$HOME"/.cache/common-lisp

120
pkgs/development/lisp-modules-obsolete/define-package.nix
View file

@ -1,120 +0,0 @@
args @ {lib, stdenv, clwrapper, baseName, packageName ? baseName
, parasites ? []
, buildSystems ? ([packageName] ++ parasites)
, version ? "latest"
, src, description, deps, buildInputs ? [], meta ? {}, overrides?(x: {})
, propagatedBuildInputs ? []
, asdFilesToKeep ? [(builtins.concatStringsSep "" [packageName ".asd"])]}:
let
deployConfigScript = ''
outhash="$out"
outhash="''${outhash##*/}"
outhash="''${outhash%%-*}"
config_script="$out"/lib/common-lisp-settings/${args.baseName}-shell-config.sh
path_config_script="$out"/lib/common-lisp-settings/${args.baseName}-path-config.sh
store_translation="$(dirname "$out"):$(dirname "$out")"
mkdir -p "$(dirname "$config_script")"
touch "$config_script"
touch "$path_config_script"
chmod a+x "$config_script"
chmod a+x "$path_config_script"
echo "if test -z \"\''${_''${outhash}_NIX_LISP_CONFIG:-}\"; then export _''${outhash}_NIX_LISP_CONFIG=1; " >> "$config_script"
echo "export NIX_CFLAGS_COMPILE='$NIX_CFLAGS_COMPILE'\"\''${NIX_CFLAGS_COMPILE:+ \$NIX_CFLAGS_COMPILE}\"" >> "$config_script"
echo "export NIX_LDFLAGS='$NIX_LDFLAGS'\"\''${NIX_LDFLAGS:+ \$NIX_LDFLAGS}\"" >> "$config_script"
echo "export NIX_LISP_COMMAND='$NIX_LISP_COMMAND'" >> "$config_script"
echo "export NIX_LISP_ASDF='$NIX_LISP_ASDF'" >> "$config_script"
set | grep NIX_CC_WRAPPER_ | sed -e 's@^NIX_CC_WRAPPER@export &@' >> "$config_script"
echo "export PATH=\"\''${PATH:+\$PATH:}$PATH\"" >> "$config_script"
echo "echo \"\$ASDF_OUTPUT_TRANSLATIONS\" | grep -E '(^|:)$store_translation(:|\$)' >/dev/null || export ASDF_OUTPUT_TRANSLATIONS=\"\''${ASDF_OUTPUT_TRANSLATIONS:+\$ASDF_OUTPUT_TRANSLATIONS:}\"'$store_translation'" >> "$config_script"
echo "source '$path_config_script'" >> "$config_script"
echo "fi" >> "$config_script"
echo "if test -z \"\''${_''${outhash}_NIX_LISP_PATH_CONFIG:-}\"; then export _''${outhash}_NIX_LISP_PATH_CONFIG=1; " >> "$path_config_script"
echo "NIX_LISP_ASDF_PATHS=\"$( echo "\''${NIX_LISP_ASDF_PATHS:-}"; echo "$NIX_LISP_ASDF_PATHS"; echo "$out/lib/common-lisp/${args.baseName}" )\"" >> "$path_config_script"
echo "export NIX_LISP_ASDF_PATHS=\$((tr ' ' '\n' | sort | uniq | tr '\n' ' ') <<< \$NIX_LISP_ASDF_PATHS)" >> $path_config_script
test -n "$LD_LIBRARY_PATH" &&
echo "export LD_LIBRARY_PATH=\"\$LD_LIBRARY_PATH\''${LD_LIBRARY_PATH:+:}\"'$LD_LIBRARY_PATH'" >> "$path_config_script"
test -n "$NIX_LISP_LD_LIBRARY_PATH" &&
echo "export NIX_LISP_LD_LIBRARY_PATH=\"\''${NIX_LISP_LD_LIBRARY_PATH:-}\''${NIX_LISP_LD_LIBRARY_PATH:+:}\"'$(echo "$NIX_LISP_LD_LIBRARY_PATH" | tr -d '\n' | tr : '\n' | sort | uniq | tr '\n' ':' | sed -e 's/:$//')'" >> "$path_config_script"
echo "fi" >> "$path_config_script"
'';
deployLaunchScript = ''
launch_script="$out"/bin/${args.baseName}-lisp-launcher.sh
mkdir -p "$(dirname "$launch_script")"
touch "$launch_script"
chmod a+x "$launch_script"
echo "#! ${stdenv.shell}" >> "$launch_script"
echo "source '$config_script'" >> "$launch_script"
echo "test -n \"\$NIX_LISP_LD_LIBRARY_PATH\" && export LD_LIBRARY_PATH=\"\$NIX_LISP_LD_LIBRARY_PATH\''${LD_LIBRARY_PATH:+:}\$LD_LIBRARY_PATH\"" >> "$launch_script"
echo '"${clwrapper}/bin/common-lisp.sh" "$@"' >> "$launch_script"
'';
moveAsdFiles = ''
find $out/lib/common-lisp/ -name '*.asd' | while read ASD_FILE; do
KEEP_THIS_ASD=0
for ALLOWED_ASD in $asdFilesToKeep; do
ALLOWED_ASD="/$ALLOWED_ASD"
ALLOWED_ASD_LENGTH=${"$"}{#ALLOWED_ASD}
ASD_FILE_LENGTH=${"$"}{#ASD_FILE}
ASD_FILE_SUFFIX_INDEX=$(expr "$ASD_FILE_LENGTH" - "$ALLOWED_ASD_LENGTH")
ASD_FILE_SUFFIX_INDEX=$(expr "$ASD_FILE_SUFFIX_INDEX" + 1)
echo $ALLOWED_ASD $ASD_FILE $ASD_FILE_SUFFIX_INDEX $(expr substr "$ASD_FILE" "$ASD_FILE_SUFFIX_INDEX" "$ASD_FILE_LENGTH")
if [ "$(expr substr "$ASD_FILE" "$ASD_FILE_SUFFIX_INDEX" "$ASD_FILE_LENGTH")" == "$ALLOWED_ASD" ]; then
KEEP_THIS_ASD=1
break
fi
done
if [ "$KEEP_THIS_ASD" == 0 ]; then
mv "$ASD_FILE"{,.sibling}
fi
done
'';
basePackage = {
name = "lisp-${baseName}-${version}";
inherit src;
dontBuild = true;
inherit deployConfigScript deployLaunchScript;
inherit asdFilesToKeep moveAsdFiles;
installPhase = ''
eval "$preInstall"
mkdir -p "$out"/share/doc/${args.baseName};
mkdir -p "$out"/lib/common-lisp/${args.baseName};
cp -r . "$out"/lib/common-lisp/${args.baseName};
cp -rf doc/* LICENCE LICENSE COPYING README README.html README.md readme.html "$out"/share/doc/${args.baseName} || true
${deployConfigScript}
${deployLaunchScript}
${moveAsdFiles}
env -i \
NIX_LISP="$NIX_LISP" \
NIX_LISP_PRELAUNCH_HOOK='nix_lisp_run_single_form "(progn
${lib.concatMapStrings (system: ''
(asdf:compile-system :${system})
(asdf:load-system :${system})
(asdf:operate (quote asdf::compile-bundle-op) :${system})
(ignore-errors (asdf:operate (quote asdf::deploy-asd-op) :${system}))
'') buildSystems}
)"' \
"$out/bin/${args.baseName}-lisp-launcher.sh"
eval "$postInstall"
'';
propagatedBuildInputs = (args.deps or []) ++ [clwrapper clwrapper.lisp clwrapper.asdf]
++ (args.propagatedBuildInputs or []);
buildInputs = buildInputs;
dontStrip=true;
ASDF_OUTPUT_TRANSLATIONS="${builtins.storeDir}/:${builtins.storeDir}";
noAuditTmpDir = true;
meta = {
inherit description version;
} // meta;
};
package = basePackage // (overrides basePackage);
in
stdenv.mkDerivation package

16
pkgs/development/lisp-modules-obsolete/from-quicklisp/asdf-description.sh
View file

@ -1,16 +0,0 @@
#! /bin/sh
[ -z "$NIX_QUICKLISP_DIR" ] && {
export NIX_QUICKLISP_DIR="$(mktemp -d --tmpdir nix-quicklisp.XXXXXX)"
}
[ -f "$NIX_QUICKLISP_DIR/setup.lisp" ] || {
"$(dirname "$0")/quicklisp-beta-env.sh" "$NIX_QUICKLISP_DIR" &> /dev/null < /dev/null
}
name="$1"
sbcl --noinform --load "$NIX_QUICKLISP_DIR"/setup.lisp --eval "(ql:quickload :$name)" \
--eval "(format t \"~a~%\" (or (asdf::system-description (asdf::find-system \"$name\")) \"\"))" \
--eval '(quit)' --script |
tee /dev/stderr | tail -n 1

174
pkgs/development/lisp-modules-obsolete/from-quicklisp/barebones-quicklisp-expression.sh
View file

@ -1,174 +0,0 @@
#! /bin/sh
name="$1"
[ -z "$NIX_LISP_PACKAGES_DEFINED_LIST" ] && export NIX_LISP_PACKAGES_DEFINED_LIST="$(mktemp)"
if [ -n "$NIX_LISP_UPDATE_PACKAGE" ] || [ -n "$NIX_LISP_UPDATE_PACKAGES" ]; then
export NIX_LISP_UPDATE_PACKAGE=
else
nix-instantiate "$(dirname "$0")"/../../../../ -A "lispPackages.$name" > /dev/null && exit
fi
grep "^$name\$" "$NIX_LISP_PACKAGES_DEFINED_LIST" > /dev/null && exit
echo "$name" >> "$NIX_LISP_PACKAGES_DEFINED_LIST"
[ -z "$NIX_QUICKLISP_DIR" ] && {
export NIX_QUICKLISP_DIR="$(mktemp -d --tmpdir nix-quicklisp.XXXXXX)"
}
[ -f "$NIX_QUICKLISP_DIR/setup.lisp" ] || {
"$(dirname "$0")/quicklisp-beta-env.sh" "$NIX_QUICKLISP_DIR" &> /dev/null < /dev/null
}
description="$("$(dirname "$0")/asdf-description.sh" "$name")"
[ -z "$description" ] && {
description="$(curl -L https://github.com/quicklisp/quicklisp-projects/raw/master/"$name"/description.txt)"
[ "$(echo "$description" | wc -l)" -gt 10 ] && description=""
}
dependencies="$("$(dirname "$0")/quicklisp-dependencies.sh" "$name" | xargs)"
ql_src="$(curl -L https://github.com/quicklisp/quicklisp-projects/raw/master/"$name"/source.txt)"
ql_src_type="${ql_src%% *}"
url="${ql_src##* }"
[ "$ql_src_type" = "kmr-git" ] && {
ql_src_type=git
url="http://git.kpe.io/$url.git"
export NIX_PREFETCH_GIT_DEEP_CLONE=1
}
[ "$ql_src_type" = ediware-http ] && {
ql_src_type=github
url="edicl/$url";
}
[ "$ql_src_type" = xach-http ] && {
ql_src_type=github
url="xach/$url";
}
[ "$ql_src_type" = github ] && {
ql_src_type=git
url="https://github.com/$url";
version="$("$(dirname "$0")/urls-from-page.sh" "$url/releases/" | grep /tag/ | head -n 1 | xargs -l1 basename)"
rev="refs/tags/$version";
}
[ "$ql_src_type" = git ] && {
fetcher="pkgs.fetchgit"
( [ "${url#git://github.com/}" != "$url" ] ||
[ "${url#https://github.com/}" != "$url" ]
) && {
url="${url/git:/https:}"
url="${url%.git}"
[ -z "$rev" ] && rev=$("$(dirname "$0")/urls-from-page.sh" "$url/commits" | grep /commit/ | head -n 1 | xargs basename)
hash=$("$(dirname "$0")/../../../build-support/fetchgit/nix-prefetch-git" "$url" "$rev" | grep . | tail -n 1)
[ -z "$version" ] && version="git-$(date +%Y%m%d)";
}
[ "${url#git://common-lisp.net/}" != "$url" ] && {
http_repo_url="$url"
http_repo_url="${http_repo_url/git:/http:}"
http_repo_url="${http_repo_url/\/projects\// /r/projects/}"
http_repo_head="$http_repo_url/refs/heads/master"
echo "$http_repo_head" >&2
[ -z "$rev" ] && rev=$(curl -L "$http_repo_head");
hash=$("$(dirname "$0")/../../../build-support/fetchgit/nix-prefetch-git" "$url" "$rev")
[ -z "$version" ] && version="git-$(date +%Y%m%d)";
}
[ "${url#http://git.b9.com/}" != "$url" ] && {
http_repo_url="$url"
http_repo_url="${http_repo_url/git:/http:}"
http_repo_head="$http_repo_url/refs/heads/master"
echo "$http_repo_head" >&2
rev=$(curl -L "$http_repo_head");
hash=$("$(dirname "$0")/../../../build-support/fetchgit/nix-prefetch-git" "$url" "$rev" | tail -n 1)
version="git-$(date +%Y%m%d)";
}
[ "${url#http://common-lisp.net/}" != "$url" ] && {
http_repo_url="$url"
http_repo_url="${http_repo_url/git:/http:}"
http_repo_head="$http_repo_url/refs/heads/master"
echo "$http_repo_head" >&2
rev=$(curl -L "$http_repo_head");
hash=$("$(dirname "$0")/../../../build-support/fetchgit/nix-prefetch-git" "$url" "$rev" | tail -n 1)
version="git-$(date +%Y%m%d)";
}
}
[ "$ql_src_type" = cvs ] && {
fetcher="pkgs.fetchcvs"
date="$(date -d yesterday +%Y-%m-%d)"
version="cvs-$date"
module="${module:-$name}"
hash=$(USE_DATE=1 "$(dirname "$0")/../../../build-support/fetchcvs/nix-prefetch-cvs" "$url" "$module" "$date")
cvsRoot="$url"
unset url
}
[ "$ql_src_type" = clnet-darcs ] && {
ql_src_type=darcs
url="http://common-lisp.net/project/$url/darcs/$url/"
}
[ "$ql_src_type" = darcs ] && {
fetcher="pkgs.fetchdarcs"
[ -z "$version" ] &&
version="$(curl "$url/_darcs/inventory" | grep '\[TAG ' | tail -n 1 | sed -e 's/.* //')"
[ -z "$version" ] &&
version="$(curl "$url/_darcs/hashed_inventory" | grep '\[TAG ' | tail -n 1 | sed -e 's/.* //')"
rev="$version";
hash=$(echo "
with (import <nixpkgs> {});
fetchdarcs {
url=''$url'';
rev=''$version'';
sha256=''0000000000000000000000000000000000000000000000000000000000000000'';
}" | nix-instantiate - | tail -n 1 |
xargs nix-store -r 2>&1 | tee /dev/stderr | grep 'instead has' | tail -n 1 |
sed -e 's/.* instead has .//;s/[^0-9a-z].*//')
}
[ "$ql_src_type" = froydware-http ] && {
dirurl="http://method-combination.net/lisp/files/";
url="$("$(dirname "$0")/urls-from-page.sh" "$dirurl" |
grep "/${url}_" | grep -v "[.]asc\$" | tail -n 1)"
ql_src_type=http
}
[ "$ql_src_type" = http ] && {
fetcher="pkgs.fetchurl";
version="$(echo "$url" | sed -re 's@.*[-_]([0-9.]+)[-._].*@\1@')"
hash="$(nix-prefetch-url "$url" | grep . | tail -n 1)"
}
[ "$ql_src_type" = https ] && {
fetcher="pkgs.fetchurl";
version="$(echo "$url" | sed -re 's@.*[-_]([0-9.]+)[-._].*@\1@')"
hash="$(nix-prefetch-url "$url" | grep . | tail -n 1)"
}
if [ "$ql_src" = '{"error":"Not Found"}' ]; then
echo "# $name: not found"
else
cat << EOF | grep -Ev '^[ ]+$'
$name = buildLispPackage rec {
baseName = "$name";
version = "${version:-\${Set me //}";
description = "$description";
deps = [$dependencies];
# Source type: $ql_src_type
src = ${fetcher:-pkgs.fetchurl} {
${url:+url = ''$url'';}
sha256 = "${hash:-0000000000000000000000000000000000000000000000000000000000000000}";
${rev:+rev = ''$rev'';}
${date:+date = ''$date'';}
${module:+module = ''$module'';}
${cvsRoot:+cvsRoot = ''$cvsRoot'';}
};
};
EOF
fi
for i in $dependencies; do "$0" "$i"; done

16
pkgs/development/lisp-modules-obsolete/from-quicklisp/quicklisp-beta-env.sh
View file

@ -1,16 +0,0 @@
#! /bin/sh
WORK_DIR=$(mktemp -d "/tmp/ql-venv-XXXXXX")
mkdir -p "${1:-.}"
TARGET="$(cd "${1:-.}"; pwd)"
curl http://beta.quicklisp.org/quicklisp.lisp > "$WORK_DIR/ql.lisp"
sbcl --noinform \
--load "$WORK_DIR/ql.lisp" \
--eval "(quicklisp-quickstart:install :path \"$TARGET/\")" \
--eval "(cl-user::quit)" \
--script
rm -rf "$WORK_DIR"

11
pkgs/development/lisp-modules-obsolete/from-quicklisp/quicklisp-dependencies.sh
View file

@ -1,11 +0,0 @@
#! /bin/sh
[ -z "$NIX_QUICKLISP_DIR" ] && {
export NIX_QUICKLISP_DIR="$(mktemp -d --tmpdir nix-quicklisp.XXXXXX)"
}
[ -f "$NIX_QUICKLISP_DIR/setup.lisp" ] || {
"$(dirname "$0")/quicklisp-beta-env.sh" "$NIX_QUICKLISP_DIR" &> /dev/null < /dev/null
}
sbcl --noinform --eval "(with-output-to-string (*standard-output*) (load \"$NIX_QUICKLISP_DIR/setup.lisp\"))" --eval "(with-output-to-string (*standard-output*) (with-output-to-string (*error-output*) (with-output-to-string (*trace-output*) (ql:quickload :$1))))" --eval "(format t \"~{~a~%~}\" (mapcar 'ql::name (mapcar 'car (cdr (ql::dependency-tree \"$1\")))))" --eval '(quit)' --script

14
pkgs/development/lisp-modules-obsolete/from-quicklisp/urls-from-page.sh
View file

@ -1,14 +0,0 @@
#! /bin/sh
url="$1"
protocol="${url%%:*}"
path="${url#$protocol://}"
server="${path%%/*}"
basepath="${path%/*}"
relpath="${path#$server}"
echo "URL: $url" >&2
curl -A 'text/html; text/xhtml; text/xml; */*' -L -k "$url" | sed -re 's/^/-/;s/[^a-zA-Z][hH][rR][eE][fF]=("([^"]*)"|'\''([^'\'']*)'\''|([^"'\'' <>&]+)[ <>&])/\n+\2\3\4\n-/g' | \
sed -e '/^-/d; s/^[+]//; /^#/d;'"s/^\\//$protocol:\\/\\/$server\\//g" | \
sed -re 's`^[^:]*$`'"$protocol://$basepath/&\`"

272
pkgs/development/lisp-modules-obsolete/lisp-packages.nix
View file

@ -1,272 +0,0 @@
{lib, stdenv, clwrapper, pkgs, sbcl, coreutils, nix, asdf}:
let lispPackages = rec {
inherit lib pkgs clwrapper stdenv;
nixLib = pkgs.lib;
callPackage = nixLib.callPackageWith lispPackages;
buildLispPackage = callPackage ./define-package.nix;
quicklisp = buildLispPackage rec {
baseName = "quicklisp";
version = "2021-02-13";
buildSystems = [];
description = "The Common Lisp package manager";
deps = [];
src = pkgs.fetchFromGitHub {
owner = "quicklisp";
repo = "quicklisp-client";
rev = "version-${version}";
sha256 = "sha256-1HLVPhl8aBaeG8dRLxBh0j0X/0wqFeNYK1CEfiELToA=";
};
overrides = x: rec {
inherit clwrapper;
quicklispdist = pkgs.fetchurl {
# Will usually be replaced with a fresh version anyway, but needs to be
# a valid distinfo.txt
url = "http://beta.quicklisp.org/dist/quicklisp/2021-12-09/distinfo.txt";
sha256 = "sha256:0gc4cv73nl7xkfwvmkmfhfx6yqf876nfm2v24v6fky9n24sh4y6w";
};
buildPhase = "true; ";
postInstall = ''
substituteAll ${./quicklisp.sh} "$out"/bin/quicklisp
chmod a+x "$out"/bin/quicklisp
cp "${quicklispdist}" "$out/lib/common-lisp/quicklisp/quicklisp-distinfo.txt"
'';
};
};
quicklisp-to-nix-system-info = stdenv.mkDerivation {
pname = "quicklisp-to-nix-system-info";
version = "1.0.0";
src = ./quicklisp-to-nix;
nativeBuildInputs = [sbcl];
buildInputs = [
lispPackages.quicklisp coreutils
];
touch = coreutils;
nix-prefetch-url = nix;
inherit quicklisp;
buildPhase = ''
${sbcl}/bin/sbcl --eval '(load #P"${asdf}/lib/common-lisp/asdf/build/asdf.lisp")' --load $src/system-info.lisp --eval '(ql-to-nix-system-info::dump-image)'
'';
installPhase = ''
mkdir -p $out/bin
cp quicklisp-to-nix-system-info $out/bin
'';
dontStrip = true;
};
quicklisp-to-nix = stdenv.mkDerivation {
pname = "quicklisp-to-nix";
version = "1.0.0";
src = ./quicklisp-to-nix;
buildDependencies = [sbcl quicklisp-to-nix-system-info];
buildInputs = with pkgs.lispPackages; [md5 cl-emb alexandria external-program];
touch = coreutils;
nix-prefetch-url = nix;
inherit quicklisp;
deps = [];
system-info = quicklisp-to-nix-system-info;
buildPhase = ''
${clwrapper}/bin/cl-wrapper.sh "${sbcl}/bin/sbcl" --eval '(load #P"${asdf}/lib/common-lisp/asdf/build/asdf.lisp")' --load $src/ql-to-nix.lisp --eval '(ql-to-nix::dump-image)'
'';
installPhase = ''
mkdir -p $out/bin
cp quicklisp-to-nix $out/bin
'';
dontStrip = true;
};
clx-truetype = buildLispPackage rec {
baseName = "clx-truetype";
version = "20160825-git";
buildSystems = [ "clx-truetype" ];
parasites = [ "clx-truetype-test" ];
description = "clx-truetype is pure common lisp solution for antialiased TrueType font rendering using CLX and XRender extension.";
deps = with pkgs.lispPackages; [
alexandria bordeaux-threads cl-aa cl-fad cl-paths cl-paths-ttf cl-store
cl-vectors clx trivial-features zpb-ttf
];
src = pkgs.fetchurl {
url = "http://beta.quicklisp.org/archive/clx-truetype/2016-08-25/clx-truetype-20160825-git.tgz";
sha256 = "0ndy067rg9w6636gxwlpnw7f3ck9nrnjb03444pprik9r3c9in67";
};
packageName = "clx-truetype";
asdFilesToKeep = ["clx-truetype.asd"];
};
cluffer = buildLispPackage rec {
baseName = "cluffer";
version = "2018-09-24";
buildSystems = [ "cluffer-base" "cluffer-simple-buffer" "cluffer-simple-line" "cluffer-standard-buffer" "cluffer-standard-line" "cluffer" ];
parasites = [ "cluffer-test" ];
description = "General purpose text-editor buffer";
deps = with pkgs.lispPackages; [
acclimation clump
];
src = pkgs.fetchFromGitHub {
owner = "robert-strandh";
repo = "cluffer";
rev = "4aad29c276a58a593064e79972ee4d77cae0af4a";
sha256 = "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj";
# date = 2018-09-24T04:45:36+02:00;
};
packageName = "cluffer";
asdFilesToKeep = [ "cluffer.asd" "cluffer-base.asd" "cluffer-simple-buffer.asd" "cluffer-simple-line.asd" "cluffer-standard-buffer.asd" "cluffer-standard-line.asd" ];
};
nyxt = pkgs.lispPackages.buildLispPackage rec {
baseName = "nyxt";
version = "2.2.4";
description = "Browser";
overrides = x: {
postInstall = ''
echo "Building nyxt binary"
(
source "$out/lib/common-lisp-settings"/*-shell-config.sh
cd "$out/lib/common-lisp"/*/
makeFlags="''${makeFlags:-}"
make LISP=common-lisp.sh NYXT_INTERNAL_QUICKLISP=false PREFIX="$out" $makeFlags all
make LISP=common-lisp.sh NYXT_INTERNAL_QUICKLISP=false PREFIX="$out" $makeFlags install
cp nyxt "$out/bin/nyxt"
)
NIX_LISP_PRELAUNCH_HOOK='
nix_lisp_build_system nyxt/gtk-application \
"(asdf/system:component-entry-point (asdf:find-system :nyxt/gtk-application))" \
"" "(format *error-output* \"Alien objects:~%~s~%\" sb-alien::*shared-objects*)"
' "$out/bin/nyxt-lisp-launcher.sh"
cp "$out/lib/common-lisp/nyxt/nyxt" "$out/bin/"
'';
# Prevent nyxt from trying to obtain dependencies as submodules
makeFlags = [ "NYXT_SUBMODULES=false" ] ++ x.buildFlags or [];
patches = x.patches or [] ++ [
# Work around crash when opening _any_ URL
# https://github.com/atlas-engineer/nyxt/issues/1781
# https://github.com/NixOS/nixpkgs/issues/158005
(pkgs.fetchpatch {
name = "nyxt-webkit-disable-sandbox.patch";
url = "https://github.com/atlas-engineer/nyxt/commit/48ac0d8727f1ca1428188a1ab2c05b7be5f6cc51.patch";
sha256 = "0570mcfn5wmjha6jmfdgglp0w5b7rpfnv3flzn77clgbknwbxi0m";
})
];
};
deps = with pkgs.lispPackages; [
alexandria
bordeaux-threads
calispel
cl-css
cl-json
cl-markup
cl-ppcre
cl-ppcre-unicode
cl-prevalence
closer-mop
cl-containers
cl-qrencode
clss
cluffer
moptilities
dexador
enchant
file-attributes
iolib
local-time
log4cl
lparallel
mk-string-metrics
osicat
parenscript
quri
serapeum
spinneret
str
plump
swank
trivia
trivial-clipboard
trivial-features
trivial-garbage
trivial-package-local-nicknames
trivial-types
unix-opts
cl-html-diff
hu_dot_dwim_dot_defclass-star
cl-custom-hash-table
fset
cl-cffi-gtk
cl-webkit2
cl-gobject-introspection
];
src = pkgs.fetchFromGitHub {
owner = "atlas-engineer";
repo = "nyxt";
rev = version;
sha256 = "12l7ir3q29v06jx0zng5cvlbmap7p709ka3ik6x29lw334qshm9b";
};
packageName = "nyxt";
propagatedBuildInputs = [
pkgs.libressl.out
pkgs.webkitgtk
pkgs.sbcl
];
};
mgl = buildLispPackage rec {
baseName = "mgl";
version = "2021-10-07";
description = "MGL is a machine learning library for backpropagation neural networks, boltzmann machines, gaussian processes and more";
deps = with pkgs.lispPackages; [
alexandria closer-mop array-operations lla cl-reexport mgl-mat mgl-pax
named-readtables pythonic-string-reader
];
src = pkgs.fetchFromGitHub {
owner = "melisgl";
repo = "mgl";
rev = "e697791a9bcad3b6e7b3845246a2aa55238cfef7";
sha256 = "sha256:09sf7nq7nmf9q7bh3a5ygl2i2n0nhrx5fk2kv5ili0ckv7g9x72s";
# date = 2021-10-18T14:15+02:00
};
buildSystems = [ "mgl" "mgl/test" ];
packageName = "mgl";
parasites = [ "mgl/test" ];
asdFilesToKeep = [ "mgl.asd" "mgl-example.asd" "gnuplot/mgl-gnuplot.asd" "visuals/mgl-visuals.asd" ];
};
mgl-mat = buildLispPackage rec {
baseName = "mgl-mat";
version = "2021-10-11";
description = "Multi-dimensional arrays with FFI/CUDA support";
deps = with pkgs.lispPackages; [
alexandria bordeaux-threads cffi cffi-grovel cl-cuda flexi-streams ieee-floats
lla mgl-pax static-vectors trivial-garbage cl-fad
];
src = pkgs.fetchFromGitHub {
owner = "melisgl";
repo = "mgl-mat";
rev = "3710858bc876b1b86e50f1db2abe719e92d810e7";
sha256 = "sha256:1aa2382mi55rp8pd31dz4d94yhfzh30vkggcvmvdfrr4ngffj0dx";
# date = 2021-10-18T14:15+02:00
};
packageName = "mgl-mat";
buildSystems = [ "mgl-mat" "mgl-mat/test" ];
parasites = [ "mgl-mat/test" ];
asdFilesToKeep = [ "mgl-mat.asd" ];
};
};
in lispPackages

18
pkgs/development/lisp-modules-obsolete/openssl-lib-marked.nix
View file

@ -1,18 +0,0 @@
with import ../../../default.nix {};
runCommand "openssl-lib-marked" {} ''
mkdir -p "$out/lib"
for lib in ssl crypto; do
version="${lib.getVersion openssl}"
ln -s "${lib.getLib openssl}/lib/lib$lib.so" "$out/lib/lib$lib.so.$version"
version="$(echo "$version" | sed -re 's/[a-z]+$//')"
while test -n "$version"; do
ln -sfT "${lib.getLib openssl}/lib/lib$lib.so" "$out/lib/lib$lib.so.$version"
nextversion="''${version%.*}"
if test "$version" = "$nextversion"; then
version=
else
version="$nextversion"
fi
done
done
''

25
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/_1am.nix
View file

@ -1,25 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "_1am";
version = "20141106-git";
description = "A minimal testing framework.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/1am/2014-11-06/1am-20141106-git.tgz";
sha256 = "0vnnqd4fiq9z34i1k9gqczg3j6xllwba1f6nx0b82sgsdccmsly6";
};
packageName = "1am";
asdFilesToKeep = ["1am.asd"];
overrides = x: x;
}
/* (SYSTEM 1am DESCRIPTION A minimal testing framework. SHA256
0vnnqd4fiq9z34i1k9gqczg3j6xllwba1f6nx0b82sgsdccmsly6 URL
http://beta.quicklisp.org/archive/1am/2014-11-06/1am-20141106-git.tgz MD5
c5e83c329157518e3ebfeef63e4ac269 NAME 1am FILENAME _1am DEPS NIL
DEPENDENCIES NIL VERSION 20141106-git SIBLINGS NIL PARASITES NIL) */

39
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix
View file

@ -1,39 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "_3bmd-ext-code-blocks";
version = "3bmd-20210411-git";
description = "extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma";
deps = [ args."_3bmd" args."alexandria" args."colorize" args."esrap" args."html-encode" args."split-sequence" args."trivial-with-current-source-form" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz";
sha256 = "1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp";
};
packageName = "3bmd-ext-code-blocks";
asdFilesToKeep = ["3bmd-ext-code-blocks.asd"];
overrides = x: x;
}
/* (SYSTEM 3bmd-ext-code-blocks DESCRIPTION
extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma
SHA256 1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp URL
http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz MD5
09f9290aa1708aeb469fb5154ab1a397 NAME 3bmd-ext-code-blocks FILENAME
_3bmd-ext-code-blocks DEPS
((NAME 3bmd FILENAME _3bmd) (NAME alexandria FILENAME alexandria)
(NAME colorize FILENAME colorize) (NAME esrap FILENAME esrap)
(NAME html-encode FILENAME html-encode)
(NAME split-sequence FILENAME split-sequence)
(NAME trivial-with-current-source-form FILENAME
trivial-with-current-source-form))
DEPENDENCIES
(3bmd alexandria colorize esrap html-encode split-sequence
trivial-with-current-source-form)
VERSION 3bmd-20210411-git SIBLINGS
(3bmd-ext-definition-lists 3bmd-ext-math 3bmd-ext-tables
3bmd-ext-wiki-links 3bmd-youtube-tests 3bmd-youtube 3bmd)
PARASITES NIL) */

34
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/_3bmd.nix
View file

@ -1,34 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "_3bmd";
version = "20210411-git";
description = "markdown processor in CL using esrap parser.";
deps = [ args."alexandria" args."esrap" args."split-sequence" args."trivial-with-current-source-form" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz";
sha256 = "1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp";
};
packageName = "3bmd";
asdFilesToKeep = ["3bmd.asd"];
overrides = x: x;
}
/* (SYSTEM 3bmd DESCRIPTION markdown processor in CL using esrap parser. SHA256
1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp URL
http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz MD5
09f9290aa1708aeb469fb5154ab1a397 NAME 3bmd FILENAME _3bmd DEPS
((NAME alexandria FILENAME alexandria) (NAME esrap FILENAME esrap)
(NAME split-sequence FILENAME split-sequence)
(NAME trivial-with-current-source-form FILENAME
trivial-with-current-source-form))
DEPENDENCIES
(alexandria esrap split-sequence trivial-with-current-source-form) VERSION
20210411-git SIBLINGS
(3bmd-ext-code-blocks 3bmd-ext-definition-lists 3bmd-ext-math
3bmd-ext-tables 3bmd-ext-wiki-links 3bmd-youtube-tests 3bmd-youtube)
PARASITES NIL) */

40
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/access.nix
View file

@ -1,40 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "access";
version = "20210124-git";
parasites = [ "access-test" ];
description = "A library providing functions that unify data-structure access for Common Lisp:
access and (setf access)";
deps = [ args."alexandria" args."anaphora" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/access/2021-01-24/access-20210124-git.tgz";
sha256 = "1n4j15v1ikspchcbb0bn15kk3lh78f6bxk56cs4arimm8bisyqlq";
};
packageName = "access";
asdFilesToKeep = ["access.asd"];
overrides = x: x;
}
/* (SYSTEM access DESCRIPTION
A library providing functions that unify data-structure access for Common Lisp:
access and (setf access)
SHA256 1n4j15v1ikspchcbb0bn15kk3lh78f6bxk56cs4arimm8bisyqlq URL
http://beta.quicklisp.org/archive/access/2021-01-24/access-20210124-git.tgz
MD5 d2d7d9826cbfb3de568d05a4d6bacdbe NAME access FILENAME access DEPS
((NAME alexandria FILENAME alexandria) (NAME anaphora FILENAME anaphora)
(NAME cl-interpol FILENAME cl-interpol) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME cl-unicode FILENAME cl-unicode)
(NAME closer-mop FILENAME closer-mop)
(NAME flexi-streams FILENAME flexi-streams)
(NAME iterate FILENAME iterate) (NAME lisp-unit2 FILENAME lisp-unit2)
(NAME named-readtables FILENAME named-readtables))
DEPENDENCIES
(alexandria anaphora cl-interpol cl-ppcre cl-unicode closer-mop
flexi-streams iterate lisp-unit2 named-readtables)
VERSION 20210124-git SIBLINGS NIL PARASITES (access-test)) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/acclimation.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "acclimation";
version = "20200925-git";
description = "Library supporting internationalization";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/acclimation/2020-09-25/acclimation-20200925-git.tgz";
sha256 = "11vw1h5zxicj5qxb1smiyjxafw8xk0isnzcf5g0lqis3y9ssqxbw";
};
packageName = "acclimation";
asdFilesToKeep = ["acclimation.asd"];
overrides = x: x;
}
/* (SYSTEM acclimation DESCRIPTION Library supporting internationalization
SHA256 11vw1h5zxicj5qxb1smiyjxafw8xk0isnzcf5g0lqis3y9ssqxbw URL
http://beta.quicklisp.org/archive/acclimation/2020-09-25/acclimation-20200925-git.tgz
MD5 8ce10864baef6fb0e11c78e2ee0b0ddb NAME acclimation FILENAME acclimation
DEPS NIL DEPENDENCIES NIL VERSION 20200925-git SIBLINGS
(acclimation-temperature) PARASITES NIL) */

29
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/agutil.nix
View file

@ -1,29 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "agutil";
version = "20210531-git";
description = "A collection of utility functions not found in other utility libraries.";
deps = [ args."alexandria" args."closer-mop" args."optima" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/agutil/2021-05-31/agutil-20210531-git.tgz";
sha256 = "01shs4qbr0bzmx9134cm84zbh8whbi2s5xngapd2fl8ag1rda9q1";
};
packageName = "agutil";
asdFilesToKeep = ["agutil.asd"];
overrides = x: x;
}
/* (SYSTEM agutil DESCRIPTION
A collection of utility functions not found in other utility libraries.
SHA256 01shs4qbr0bzmx9134cm84zbh8whbi2s5xngapd2fl8ag1rda9q1 URL
http://beta.quicklisp.org/archive/agutil/2021-05-31/agutil-20210531-git.tgz
MD5 99de7cd320ae2696c1707ca5b55cf40a NAME agutil FILENAME agutil DEPS
((NAME alexandria FILENAME alexandria)
(NAME closer-mop FILENAME closer-mop) (NAME optima FILENAME optima))
DEPENDENCIES (alexandria closer-mop optima) VERSION 20210531-git SIBLINGS
NIL PARASITES NIL) */

27
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/alexandria.nix
View file

@ -1,27 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "alexandria";
version = "20211209-git";
description = "Alexandria is a collection of portable public domain utilities.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/alexandria/2021-12-09/alexandria-20211209-git.tgz";
sha256 = "13xyajg5n3ad3x2hrmzni1w87b0wc41wn7manbvc3dc5n55afxk0";
};
packageName = "alexandria";
asdFilesToKeep = ["alexandria.asd"];
overrides = x: x;
}
/* (SYSTEM alexandria DESCRIPTION
Alexandria is a collection of portable public domain utilities. SHA256
13xyajg5n3ad3x2hrmzni1w87b0wc41wn7manbvc3dc5n55afxk0 URL
http://beta.quicklisp.org/archive/alexandria/2021-12-09/alexandria-20211209-git.tgz
MD5 4f578a956567ea0d6c99c2babd1752f3 NAME alexandria FILENAME alexandria
DEPS NIL DEPENDENCIES NIL VERSION 20211209-git SIBLINGS (alexandria-tests)
PARASITES NIL) */

28
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/anaphora.nix
View file

@ -1,28 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "anaphora";
version = "20211209-git";
parasites = [ "anaphora/test" ];
description = "The Anaphoric Macro Package from Hell";
deps = [ args."rt" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/anaphora/2021-12-09/anaphora-20211209-git.tgz";
sha256 = "1pi166qwf3zwswhgq8c4r84rl5d6lnn0rkb3cdf5afyxmminsadg";
};
packageName = "anaphora";
asdFilesToKeep = ["anaphora.asd"];
overrides = x: x;
}
/* (SYSTEM anaphora DESCRIPTION The Anaphoric Macro Package from Hell SHA256
1pi166qwf3zwswhgq8c4r84rl5d6lnn0rkb3cdf5afyxmminsadg URL
http://beta.quicklisp.org/archive/anaphora/2021-12-09/anaphora-20211209-git.tgz
MD5 81827cd43d29293e967916bb11c4df88 NAME anaphora FILENAME anaphora DEPS
((NAME rt FILENAME rt)) DEPENDENCIES (rt) VERSION 20211209-git SIBLINGS NIL
PARASITES (anaphora/test)) */

35
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/arnesi.nix
View file

@ -1,35 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "arnesi";
version = "20170403-git";
parasites = [ "arnesi/cl-ppcre-extras" "arnesi/slime-extras" ];
description = "A bag-of-tools utilities library used to aid in implementing the bese.it toolkit";
deps = [ args."alexandria" args."cl-ppcre" args."closer-mop" args."collectors" args."iterate" args."swank" args."symbol-munger" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/arnesi/2017-04-03/arnesi-20170403-git.tgz";
sha256 = "01kirjpgv5pgbcdxjrnw3ld4jw7wrqm3rgqnxwac4gxaphr2s6q4";
};
packageName = "arnesi";
asdFilesToKeep = ["arnesi.asd"];
overrides = x: x;
}
/* (SYSTEM arnesi DESCRIPTION
A bag-of-tools utilities library used to aid in implementing the bese.it toolkit
SHA256 01kirjpgv5pgbcdxjrnw3ld4jw7wrqm3rgqnxwac4gxaphr2s6q4 URL
http://beta.quicklisp.org/archive/arnesi/2017-04-03/arnesi-20170403-git.tgz
MD5 bbb34e1a646b2cc489766690c741d964 NAME arnesi FILENAME arnesi DEPS
((NAME alexandria FILENAME alexandria) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME closer-mop FILENAME closer-mop)
(NAME collectors FILENAME collectors) (NAME iterate FILENAME iterate)
(NAME swank FILENAME swank) (NAME symbol-munger FILENAME symbol-munger))
DEPENDENCIES
(alexandria cl-ppcre closer-mop collectors iterate swank symbol-munger)
VERSION 20170403-git SIBLINGS NIL PARASITES
(arnesi/cl-ppcre-extras arnesi/slime-extras)) */

32
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/array-operations.nix
View file

@ -1,32 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "array-operations";
version = "20210411-git";
parasites = [ "array-operations/tests" ];
description = "Simple array operations library for Common Lisp.";
deps = [ args."alexandria" args."anaphora" args."clunit2" args."let-plus" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/array-operations/2021-04-11/array-operations-20210411-git.tgz";
sha256 = "0l6wxd3a1xdcmcsc93prq8ymainfsy15imiwnaik1i9g94fcbjz8";
};
packageName = "array-operations";
asdFilesToKeep = ["array-operations.asd"];
overrides = x: x;
}
/* (SYSTEM array-operations DESCRIPTION
Simple array operations library for Common Lisp. SHA256
0l6wxd3a1xdcmcsc93prq8ymainfsy15imiwnaik1i9g94fcbjz8 URL
http://beta.quicklisp.org/archive/array-operations/2021-04-11/array-operations-20210411-git.tgz
MD5 902c6034c006bc6ca88ef59e7ff2b1aa NAME array-operations FILENAME
array-operations DEPS
((NAME alexandria FILENAME alexandria) (NAME anaphora FILENAME anaphora)
(NAME clunit2 FILENAME clunit2) (NAME let-plus FILENAME let-plus))
DEPENDENCIES (alexandria anaphora clunit2 let-plus) VERSION 20210411-git
SIBLINGS NIL PARASITES (array-operations/tests)) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/array-utils.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "array-utils";
version = "20201220-git";
description = "A few utilities for working with arrays.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/array-utils/2020-12-20/array-utils-20201220-git.tgz";
sha256 = "11y6k8gzzcj00jyccg2k9nh6rvivcvh23z4yzjfly7adygd3n717";
};
packageName = "array-utils";
asdFilesToKeep = ["array-utils.asd"];
overrides = x: x;
}
/* (SYSTEM array-utils DESCRIPTION A few utilities for working with arrays.
SHA256 11y6k8gzzcj00jyccg2k9nh6rvivcvh23z4yzjfly7adygd3n717 URL
http://beta.quicklisp.org/archive/array-utils/2020-12-20/array-utils-20201220-git.tgz
MD5 d6ed906f28c46b2ab0335ec1fc05f8af NAME array-utils FILENAME array-utils
DEPS NIL DEPENDENCIES NIL VERSION 20201220-git SIBLINGS (array-utils-test)
PARASITES NIL) */

31
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/arrows.nix
View file

@ -1,31 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "arrows";
version = "20181018-git";
parasites = [ "arrows/test" ];
description = "Implements -> and ->> from Clojure, as well as several expansions on the
idea.";
deps = [ args."hu_dot_dwim_dot_stefil" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/arrows/2018-10-18/arrows-20181018-git.tgz";
sha256 = "1b13pnn71z1dv1cwysh6p5jfgjsp3q8ivsdxfspl1hg1nh9mqa7r";
};
packageName = "arrows";
asdFilesToKeep = ["arrows.asd"];
overrides = x: x;
}
/* (SYSTEM arrows DESCRIPTION
Implements -> and ->> from Clojure, as well as several expansions on the
idea.
SHA256 1b13pnn71z1dv1cwysh6p5jfgjsp3q8ivsdxfspl1hg1nh9mqa7r URL
http://beta.quicklisp.org/archive/arrows/2018-10-18/arrows-20181018-git.tgz
MD5 c60b5d79680de19baad018a0fe87bc48 NAME arrows FILENAME arrows DEPS
((NAME hu.dwim.stefil FILENAME hu_dot_dwim_dot_stefil)) DEPENDENCIES
(hu.dwim.stefil) VERSION 20181018-git SIBLINGS NIL PARASITES (arrows/test)) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/asdf-package-system.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "asdf-package-system";
version = "20150608-git";
description = "System lacks description";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/asdf-package-system/2015-06-08/asdf-package-system-20150608-git.tgz";
sha256 = "17lfwfc15hcag8a2jsaxkx42wmz2mwkvxf6vb2h9cim7dwsnyy29";
};
packageName = "asdf-package-system";
asdFilesToKeep = ["asdf-package-system.asd"];
overrides = x: x;
}
/* (SYSTEM asdf-package-system DESCRIPTION System lacks description SHA256
17lfwfc15hcag8a2jsaxkx42wmz2mwkvxf6vb2h9cim7dwsnyy29 URL
http://beta.quicklisp.org/archive/asdf-package-system/2015-06-08/asdf-package-system-20150608-git.tgz
MD5 9eee9d811aec4894843ac1d8ae6cbccd NAME asdf-package-system FILENAME
asdf-package-system DEPS NIL DEPENDENCIES NIL VERSION 20150608-git SIBLINGS
NIL PARASITES NIL) */

27
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/asdf-system-connections.nix
View file

@ -1,27 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "asdf-system-connections";
version = "20170124-git";
description = "Allows for ASDF system to be connected so that auto-loading may occur.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/asdf-system-connections/2017-01-24/asdf-system-connections-20170124-git.tgz";
sha256 = "0h8237bq3niw6glcsps77n1ykcmc5bjkcrbjyxjgkmcb1c5kwwpq";
};
packageName = "asdf-system-connections";
asdFilesToKeep = ["asdf-system-connections.asd"];
overrides = x: x;
}
/* (SYSTEM asdf-system-connections DESCRIPTION
Allows for ASDF system to be connected so that auto-loading may occur.
SHA256 0h8237bq3niw6glcsps77n1ykcmc5bjkcrbjyxjgkmcb1c5kwwpq URL
http://beta.quicklisp.org/archive/asdf-system-connections/2017-01-24/asdf-system-connections-20170124-git.tgz
MD5 23bdbb69c433568e3e15ed705b803992 NAME asdf-system-connections FILENAME
asdf-system-connections DEPS NIL DEPENDENCIES NIL VERSION 20170124-git
SIBLINGS NIL PARASITES NIL) */

28
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/babel.nix
View file

@ -1,28 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "babel";
version = "20200925-git";
description = "Babel, a charset conversion library.";
deps = [ args."alexandria" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/babel/2020-09-25/babel-20200925-git.tgz";
sha256 = "1hpjm2whw7zla9igzj50y3nibii0mfg2a6y6nslaf5vpkni88jfi";
};
packageName = "babel";
asdFilesToKeep = ["babel.asd"];
overrides = x: x;
}
/* (SYSTEM babel DESCRIPTION Babel, a charset conversion library. SHA256
1hpjm2whw7zla9igzj50y3nibii0mfg2a6y6nslaf5vpkni88jfi URL
http://beta.quicklisp.org/archive/babel/2020-09-25/babel-20200925-git.tgz
MD5 7f64d3be80bcba19d9caeaede5dea6d8 NAME babel FILENAME babel DEPS
((NAME alexandria FILENAME alexandria)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES (alexandria trivial-features) VERSION 20200925-git SIBLINGS
(babel-streams babel-tests) PARASITES NIL) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/binomial-heap.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "binomial-heap";
version = "20130420-git";
description = "A compact binomial heap implementation.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/binomial-heap/2013-04-20/binomial-heap-20130420-git.tgz";
sha256 = "0fl062psd0jn94raip46lq342xmsq0xgrql6v5f9j9w0ps0dg2ap";
};
packageName = "binomial-heap";
asdFilesToKeep = ["binomial-heap.asd"];
overrides = x: x;
}
/* (SYSTEM binomial-heap DESCRIPTION A compact binomial heap implementation.
SHA256 0fl062psd0jn94raip46lq342xmsq0xgrql6v5f9j9w0ps0dg2ap URL
http://beta.quicklisp.org/archive/binomial-heap/2013-04-20/binomial-heap-20130420-git.tgz
MD5 ca40cb01b88a3fe902cc4cc25fb2d242 NAME binomial-heap FILENAME
binomial-heap DEPS NIL DEPENDENCIES NIL VERSION 20130420-git SIBLINGS NIL
PARASITES NIL) */

28
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/binpack.nix
View file

@ -1,28 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "binpack";
version = "20201220-git";
parasites = [ "binpack/2" ];
description = "Rectangle packer for sprite/texture atlases";
deps = [ args."alexandria" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/binpack/2020-12-20/binpack-20201220-git.tgz";
sha256 = "1kyl19kjsii2nrbf229c5fb3bjw7r25736f991g2j8vig991imwm";
};
packageName = "binpack";
asdFilesToKeep = ["binpack.asd"];
overrides = x: x;
}
/* (SYSTEM binpack DESCRIPTION Rectangle packer for sprite/texture atlases
SHA256 1kyl19kjsii2nrbf229c5fb3bjw7r25736f991g2j8vig991imwm URL
http://beta.quicklisp.org/archive/binpack/2020-12-20/binpack-20201220-git.tgz
MD5 1ac4eaa76586091edb77111ea033f316 NAME binpack FILENAME binpack DEPS
((NAME alexandria FILENAME alexandria)) DEPENDENCIES (alexandria) VERSION
20201220-git SIBLINGS (binpack-test) PARASITES (binpack/2)) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/blackbird.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "blackbird";
version = "20160531-git";
description = "A promise implementation for Common Lisp.";
deps = [ args."vom" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/blackbird/2016-05-31/blackbird-20160531-git.tgz";
sha256 = "0l053fb5fdz1q6dyfgys6nmbairc3aig4wjl5abpf8b1paf7gzq9";
};
packageName = "blackbird";
asdFilesToKeep = ["blackbird.asd"];
overrides = x: x;
}
/* (SYSTEM blackbird DESCRIPTION A promise implementation for Common Lisp.
SHA256 0l053fb5fdz1q6dyfgys6nmbairc3aig4wjl5abpf8b1paf7gzq9 URL
http://beta.quicklisp.org/archive/blackbird/2016-05-31/blackbird-20160531-git.tgz
MD5 5cb13dc06a0eae8dcba14714d2b5365d NAME blackbird FILENAME blackbird DEPS
((NAME vom FILENAME vom)) DEPENDENCIES (vom) VERSION 20160531-git SIBLINGS
(blackbird-test) PARASITES NIL) */

31
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/bordeaux-threads.nix
View file

@ -1,31 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "bordeaux-threads";
version = "v0.8.8";
parasites = [ "bordeaux-threads/test" ];
description = "Bordeaux Threads makes writing portable multi-threaded apps simple.";
deps = [ args."alexandria" args."fiveam" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/bordeaux-threads/2020-06-10/bordeaux-threads-v0.8.8.tgz";
sha256 = "1ppb7lvr796k1j4hi0jnp717v9zxy6vq4f5cyzgn7svg1ic6l0pp";
};
packageName = "bordeaux-threads";
asdFilesToKeep = ["bordeaux-threads.asd"];
overrides = x: x;
}
/* (SYSTEM bordeaux-threads DESCRIPTION
Bordeaux Threads makes writing portable multi-threaded apps simple. SHA256
1ppb7lvr796k1j4hi0jnp717v9zxy6vq4f5cyzgn7svg1ic6l0pp URL
http://beta.quicklisp.org/archive/bordeaux-threads/2020-06-10/bordeaux-threads-v0.8.8.tgz
MD5 1922316721bcaa10142ed07c31b178e5 NAME bordeaux-threads FILENAME
bordeaux-threads DEPS
((NAME alexandria FILENAME alexandria) (NAME fiveam FILENAME fiveam))
DEPENDENCIES (alexandria fiveam) VERSION v0.8.8 SIBLINGS NIL PARASITES
(bordeaux-threads/test)) */

49
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/buildnode-xhtml.nix
View file

@ -1,49 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "buildnode-xhtml";
version = "buildnode-20170403-git";
description = "Tool for building up an xml dom of an excel spreadsheet nicely.";
deps = [ args."alexandria" args."babel" args."buildnode" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."cxml" args."flexi-streams" args."iterate" args."named-readtables" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz";
sha256 = "1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6";
};
packageName = "buildnode-xhtml";
asdFilesToKeep = ["buildnode-xhtml.asd"];
overrides = x: x;
}
/* (SYSTEM buildnode-xhtml DESCRIPTION
Tool for building up an xml dom of an excel spreadsheet nicely. SHA256
1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6 URL
http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz
MD5 b917f0d6c20489febbef0d5b954c350d NAME buildnode-xhtml FILENAME
buildnode-xhtml DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME buildnode FILENAME buildnode)
(NAME cl-interpol FILENAME cl-interpol) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME cl-unicode FILENAME cl-unicode)
(NAME closer-mop FILENAME closer-mop)
(NAME closure-common FILENAME closure-common)
(NAME closure-html FILENAME closure-html)
(NAME collectors FILENAME collectors) (NAME cxml FILENAME cxml)
(NAME flexi-streams FILENAME flexi-streams)
(NAME iterate FILENAME iterate)
(NAME named-readtables FILENAME named-readtables)
(NAME puri FILENAME puri) (NAME split-sequence FILENAME split-sequence)
(NAME swank FILENAME swank) (NAME symbol-munger FILENAME symbol-munger)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams))
DEPENDENCIES
(alexandria babel buildnode cl-interpol cl-ppcre cl-unicode closer-mop
closure-common closure-html collectors cxml flexi-streams iterate
named-readtables puri split-sequence swank symbol-munger trivial-features
trivial-gray-streams)
VERSION buildnode-20170403-git SIBLINGS
(buildnode-excel buildnode-html5 buildnode-kml buildnode-xul buildnode)
PARASITES NIL) */

50
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/buildnode.nix
View file

@ -1,50 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "buildnode";
version = "20170403-git";
parasites = [ "buildnode-test" ];
description = "Tool for building up an xml dom nicely.";
deps = [ args."alexandria" args."babel" args."buildnode-xhtml" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."cxml" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz";
sha256 = "1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6";
};
packageName = "buildnode";
asdFilesToKeep = ["buildnode.asd"];
overrides = x: x;
}
/* (SYSTEM buildnode DESCRIPTION Tool for building up an xml dom nicely. SHA256
1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6 URL
http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz
MD5 b917f0d6c20489febbef0d5b954c350d NAME buildnode FILENAME buildnode DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME buildnode-xhtml FILENAME buildnode-xhtml)
(NAME cl-interpol FILENAME cl-interpol) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME cl-unicode FILENAME cl-unicode)
(NAME closer-mop FILENAME closer-mop)
(NAME closure-common FILENAME closure-common)
(NAME closure-html FILENAME closure-html)
(NAME collectors FILENAME collectors) (NAME cxml FILENAME cxml)
(NAME flexi-streams FILENAME flexi-streams)
(NAME iterate FILENAME iterate) (NAME lisp-unit2 FILENAME lisp-unit2)
(NAME named-readtables FILENAME named-readtables)
(NAME puri FILENAME puri) (NAME split-sequence FILENAME split-sequence)
(NAME swank FILENAME swank) (NAME symbol-munger FILENAME symbol-munger)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams))
DEPENDENCIES
(alexandria babel buildnode-xhtml cl-interpol cl-ppcre cl-unicode
closer-mop closure-common closure-html collectors cxml flexi-streams
iterate lisp-unit2 named-readtables puri split-sequence swank
symbol-munger trivial-features trivial-gray-streams)
VERSION 20170403-git SIBLINGS
(buildnode-excel buildnode-html5 buildnode-kml buildnode-xhtml
buildnode-xul)
PARASITES (buildnode-test)) */

36
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/calispel.nix
View file

@ -1,36 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "calispel";
version = "20170830-git";
parasites = [ "calispel-test" ];
description = "Thread-safe message-passing channels, in the style of
the occam programming language.";
deps = [ args."alexandria" args."bordeaux-threads" args."eager-future2" args."jpl-queues" args."jpl-util" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/calispel/2017-08-30/calispel-20170830-git.tgz";
sha256 = "0qwmzmyh63jlw5bdv4wf458n1dz9k77gd5b4ix1kd6xrzx247k7i";
};
packageName = "calispel";
asdFilesToKeep = ["calispel.asd"];
overrides = x: x;
}
/* (SYSTEM calispel DESCRIPTION
Thread-safe message-passing channels, in the style of
the occam programming language.
SHA256 0qwmzmyh63jlw5bdv4wf458n1dz9k77gd5b4ix1kd6xrzx247k7i URL
http://beta.quicklisp.org/archive/calispel/2017-08-30/calispel-20170830-git.tgz
MD5 1fba6e4b2055f5d1f0a78387e29552b1 NAME calispel FILENAME calispel DEPS
((NAME alexandria FILENAME alexandria)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME eager-future2 FILENAME eager-future2)
(NAME jpl-queues FILENAME jpl-queues) (NAME jpl-util FILENAME jpl-util))
DEPENDENCIES
(alexandria bordeaux-threads eager-future2 jpl-queues jpl-util) VERSION
20170830-git SIBLINGS NIL PARASITES (calispel-test)) */

31
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cffi-grovel.nix
View file

@ -1,31 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cffi-grovel";
version = "cffi_0.24.1";
description = "The CFFI Groveller";
deps = [ args."alexandria" args."babel" args."cffi" args."cffi-toolchain" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz";
sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh";
};
packageName = "cffi-grovel";
asdFilesToKeep = ["cffi-grovel.asd"];
overrides = x: x;
}
/* (SYSTEM cffi-grovel DESCRIPTION The CFFI Groveller SHA256
1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL
http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5
c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-grovel FILENAME cffi-grovel DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME cffi FILENAME cffi) (NAME cffi-toolchain FILENAME cffi-toolchain)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES (alexandria babel cffi cffi-toolchain trivial-features)
VERSION cffi_0.24.1 SIBLINGS
(cffi-examples cffi-libffi cffi-tests cffi-toolchain cffi-uffi-compat cffi)
PARASITES NIL) */

32
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cffi-toolchain.nix
View file

@ -1,32 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cffi-toolchain";
version = "cffi_0.24.1";
description = "The CFFI toolchain";
deps = [ args."alexandria" args."asdf" args."babel" args."cffi" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz";
sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh";
};
packageName = "cffi-toolchain";
asdFilesToKeep = ["cffi-toolchain.asd"];
overrides = x: x;
}
/* (SYSTEM cffi-toolchain DESCRIPTION The CFFI toolchain SHA256
1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL
http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5
c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-toolchain FILENAME
cffi-toolchain DEPS
((NAME alexandria FILENAME alexandria) (NAME asdf FILENAME asdf)
(NAME babel FILENAME babel) (NAME cffi FILENAME cffi)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES (alexandria asdf babel cffi trivial-features) VERSION
cffi_0.24.1 SIBLINGS
(cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-uffi-compat cffi)
PARASITES NIL) */

32
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cffi-uffi-compat.nix
View file

@ -1,32 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cffi-uffi-compat";
version = "cffi_0.24.1";
description = "UFFI Compatibility Layer for CFFI";
deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz";
sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh";
};
packageName = "cffi-uffi-compat";
asdFilesToKeep = ["cffi-uffi-compat.asd"];
overrides = x: x;
}
/* (SYSTEM cffi-uffi-compat DESCRIPTION UFFI Compatibility Layer for CFFI
SHA256 1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL
http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5
c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-uffi-compat FILENAME
cffi-uffi-compat DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME cffi FILENAME cffi)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES (alexandria babel cffi trivial-features) VERSION cffi_0.24.1
SIBLINGS
(cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-toolchain cffi)
PARASITES NIL) */

35
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cffi.nix
View file

@ -1,35 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cffi";
version = "cffi_0.24.1";
parasites = [ "cffi/c2ffi" "cffi/c2ffi-generator" ];
description = "The Common Foreign Function Interface";
deps = [ args."alexandria" args."babel" args."cl-json" args."cl-ppcre" args."trivial-features" args."uiop" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz";
sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh";
};
packageName = "cffi";
asdFilesToKeep = ["cffi.asd"];
overrides = x: x;
}
/* (SYSTEM cffi DESCRIPTION The Common Foreign Function Interface SHA256
1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL
http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5
c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi FILENAME cffi DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME cl-json FILENAME cl-json) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME trivial-features FILENAME trivial-features)
(NAME uiop FILENAME uiop))
DEPENDENCIES (alexandria babel cl-json cl-ppcre trivial-features uiop)
VERSION cffi_0.24.1 SIBLINGS
(cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-toolchain
cffi-uffi-compat)
PARASITES (cffi/c2ffi cffi/c2ffi-generator)) */

32
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/chanl.nix
View file

@ -1,32 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "chanl";
version = "20210411-git";
parasites = [ "chanl/examples" "chanl/tests" ];
description = "Communicating Sequential Process support for Common Lisp";
deps = [ args."alexandria" args."bordeaux-threads" args."fiveam" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/chanl/2021-04-11/chanl-20210411-git.tgz";
sha256 = "1c1yiw616q5hv6vzyg1y4kg68v94p37s5jrq387rwadfnnf46rgi";
};
packageName = "chanl";
asdFilesToKeep = ["chanl.asd"];
overrides = x: x;
}
/* (SYSTEM chanl DESCRIPTION
Communicating Sequential Process support for Common Lisp SHA256
1c1yiw616q5hv6vzyg1y4kg68v94p37s5jrq387rwadfnnf46rgi URL
http://beta.quicklisp.org/archive/chanl/2021-04-11/chanl-20210411-git.tgz
MD5 efaa5705b5feaa718290d25a95e2a684 NAME chanl FILENAME chanl DEPS
((NAME alexandria FILENAME alexandria)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME fiveam FILENAME fiveam))
DEPENDENCIES (alexandria bordeaux-threads fiveam) VERSION 20210411-git
SIBLINGS NIL PARASITES (chanl/examples chanl/tests)) */

32
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/check-it.nix
View file

@ -1,32 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "check-it";
version = "20150709-git";
parasites = [ "check-it-test" ];
description = "A randomized property-based testing tool for Common Lisp.";
deps = [ args."alexandria" args."closer-mop" args."optima" args."stefil" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/check-it/2015-07-09/check-it-20150709-git.tgz";
sha256 = "1bx3ndkkl3w7clkqplhy6c2sz46pcp5w76j610gynzv7scz72iw2";
};
packageName = "check-it";
asdFilesToKeep = ["check-it.asd"];
overrides = x: x;
}
/* (SYSTEM check-it DESCRIPTION
A randomized property-based testing tool for Common Lisp. SHA256
1bx3ndkkl3w7clkqplhy6c2sz46pcp5w76j610gynzv7scz72iw2 URL
http://beta.quicklisp.org/archive/check-it/2015-07-09/check-it-20150709-git.tgz
MD5 0baae55e5a9c8c884202cbc51e634c42 NAME check-it FILENAME check-it DEPS
((NAME alexandria FILENAME alexandria)
(NAME closer-mop FILENAME closer-mop) (NAME optima FILENAME optima)
(NAME stefil FILENAME stefil))
DEPENDENCIES (alexandria closer-mop optima stefil) VERSION 20150709-git
SIBLINGS NIL PARASITES (check-it-test)) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/chipz.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "chipz";
version = "20210807-git";
description = "A library for decompressing deflate, zlib, and gzip data";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/chipz/2021-08-07/chipz-20210807-git.tgz";
sha256 = "0g7xhh4yq9azjq7gnszaq2kbxima2q30apb3rrglc1ign973hr8x";
};
packageName = "chipz";
asdFilesToKeep = ["chipz.asd"];
overrides = x: x;
}
/* (SYSTEM chipz DESCRIPTION
A library for decompressing deflate, zlib, and gzip data SHA256
0g7xhh4yq9azjq7gnszaq2kbxima2q30apb3rrglc1ign973hr8x URL
http://beta.quicklisp.org/archive/chipz/2021-08-07/chipz-20210807-git.tgz
MD5 11438e3bc60c39294c337cb232ae8040 NAME chipz FILENAME chipz DEPS NIL
DEPENDENCIES NIL VERSION 20210807-git SIBLINGS NIL PARASITES NIL) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/chunga.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "chunga";
version = "20200427-git";
description = "System lacks description";
deps = [ args."trivial-gray-streams" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/chunga/2020-04-27/chunga-20200427-git.tgz";
sha256 = "0p6dlnan6raincd682brcjbklyvmkfkhz0yzp2bkfw67s9615bkk";
};
packageName = "chunga";
asdFilesToKeep = ["chunga.asd"];
overrides = x: x;
}
/* (SYSTEM chunga DESCRIPTION System lacks description SHA256
0p6dlnan6raincd682brcjbklyvmkfkhz0yzp2bkfw67s9615bkk URL
http://beta.quicklisp.org/archive/chunga/2020-04-27/chunga-20200427-git.tgz
MD5 ec31aa63a1b594a197ad45e5e65c4cc4 NAME chunga FILENAME chunga DEPS
((NAME trivial-gray-streams FILENAME trivial-gray-streams)) DEPENDENCIES
(trivial-gray-streams) VERSION 20200427-git SIBLINGS NIL PARASITES NIL) */

37
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/circular-streams.nix
View file

@ -1,37 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "circular-streams";
version = "20161204-git";
description = "Circularly readable streams for Common Lisp";
deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz";
sha256 = "1i29b9sciqs5x59hlkdj2r4siyqgrwj5hb4lnc80jgfqvzbq4128";
};
packageName = "circular-streams";
asdFilesToKeep = ["circular-streams.asd"];
overrides = x: x;
}
/* (SYSTEM circular-streams DESCRIPTION
Circularly readable streams for Common Lisp SHA256
1i29b9sciqs5x59hlkdj2r4siyqgrwj5hb4lnc80jgfqvzbq4128 URL
http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz
MD5 2383f3b82fa3335d9106e1354a678db8 NAME circular-streams FILENAME
circular-streams DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME cffi FILENAME cffi) (NAME cffi-grovel FILENAME cffi-grovel)
(NAME cffi-toolchain FILENAME cffi-toolchain)
(NAME fast-io FILENAME fast-io)
(NAME static-vectors FILENAME static-vectors)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams))
DEPENDENCIES
(alexandria babel cffi cffi-grovel cffi-toolchain fast-io static-vectors
trivial-features trivial-gray-streams)
VERSION 20161204-git SIBLINGS (circular-streams-test) PARASITES NIL) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-aa.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-aa";
version = "cl-vectors-20180228-git";
description = "cl-aa: polygon rasterizer";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz";
sha256 = "0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly";
};
packageName = "cl-aa";
asdFilesToKeep = ["cl-aa.asd"];
overrides = x: x;
}
/* (SYSTEM cl-aa DESCRIPTION cl-aa: polygon rasterizer SHA256
0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly URL
http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz
MD5 9d9629786d4f2c19c15cc6cd3049c343 NAME cl-aa FILENAME cl-aa DEPS NIL
DEPENDENCIES NIL VERSION cl-vectors-20180228-git SIBLINGS
(cl-aa-misc cl-paths-ttf cl-paths cl-vectors) PARASITES NIL) */

26
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-annot.nix
View file

@ -1,26 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-annot";
version = "20150608-git";
description = "Python-like Annotation Syntax for Common Lisp";
deps = [ args."alexandria" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz";
sha256 = "0ixsp20rk498phv3iivipn3qbw7a7x260x63hc6kpv2s746lpdg3";
};
packageName = "cl-annot";
asdFilesToKeep = ["cl-annot.asd"];
overrides = x: x;
}
/* (SYSTEM cl-annot DESCRIPTION Python-like Annotation Syntax for Common Lisp
SHA256 0ixsp20rk498phv3iivipn3qbw7a7x260x63hc6kpv2s746lpdg3 URL
http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz
MD5 35d8f79311bda4dd86002d11edcd0a21 NAME cl-annot FILENAME cl-annot DEPS
((NAME alexandria FILENAME alexandria)) DEPENDENCIES (alexandria) VERSION
20150608-git SIBLINGS NIL PARASITES NIL) */

25
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-anonfun.nix
View file

@ -1,25 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-anonfun";
version = "20111203-git";
description = "Anonymous function helpers for Common Lisp";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-anonfun/2011-12-03/cl-anonfun-20111203-git.tgz";
sha256 = "16r3v3yba41smkqpz0qvzabkxashl39klfb6vxhzbly696x87p1m";
};
packageName = "cl-anonfun";
asdFilesToKeep = ["cl-anonfun.asd"];
overrides = x: x;
}
/* (SYSTEM cl-anonfun DESCRIPTION Anonymous function helpers for Common Lisp
SHA256 16r3v3yba41smkqpz0qvzabkxashl39klfb6vxhzbly696x87p1m URL
http://beta.quicklisp.org/archive/cl-anonfun/2011-12-03/cl-anonfun-20111203-git.tgz
MD5 915bda1a7653d42090f8d20a1ad85d0b NAME cl-anonfun FILENAME cl-anonfun
DEPS NIL DEPENDENCIES NIL VERSION 20111203-git SIBLINGS NIL PARASITES NIL) */

30
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-ansi-text.nix
View file

@ -1,30 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-ansi-text";
version = "20211020-git";
description = "ANSI control string characters, focused on color";
deps = [ args."alexandria" args."cl-colors2" args."cl-ppcre" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-ansi-text/2021-10-20/cl-ansi-text-20211020-git.tgz";
sha256 = "1lmxmdf4sm7apkczp0y07rlsayc5adyv2i85r6p7s60w6sianjr6";
};
packageName = "cl-ansi-text";
asdFilesToKeep = ["cl-ansi-text.asd"];
overrides = x: x;
}
/* (SYSTEM cl-ansi-text DESCRIPTION
ANSI control string characters, focused on color SHA256
1lmxmdf4sm7apkczp0y07rlsayc5adyv2i85r6p7s60w6sianjr6 URL
http://beta.quicklisp.org/archive/cl-ansi-text/2021-10-20/cl-ansi-text-20211020-git.tgz
MD5 5411766beeb4180218b449454b67837f NAME cl-ansi-text FILENAME
cl-ansi-text DEPS
((NAME alexandria FILENAME alexandria)
(NAME cl-colors2 FILENAME cl-colors2) (NAME cl-ppcre FILENAME cl-ppcre))
DEPENDENCIES (alexandria cl-colors2 cl-ppcre) VERSION 20211020-git SIBLINGS
(cl-ansi-text.test) PARASITES NIL) */

27
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-ascii-table.nix
View file

@ -1,27 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-ascii-table";
version = "20200610-git";
description = "Common Lisp library to present tabular data in ascii-art table.";
deps = [ ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-ascii-table/2020-06-10/cl-ascii-table-20200610-git.tgz";
sha256 = "00395cbmjwlywyks3zd4mqp0w7yyms61ywp06knv1gbf847vy7yi";
};
packageName = "cl-ascii-table";
asdFilesToKeep = ["cl-ascii-table.asd"];
overrides = x: x;
}
/* (SYSTEM cl-ascii-table DESCRIPTION
Common Lisp library to present tabular data in ascii-art table. SHA256
00395cbmjwlywyks3zd4mqp0w7yyms61ywp06knv1gbf847vy7yi URL
http://beta.quicklisp.org/archive/cl-ascii-table/2020-06-10/cl-ascii-table-20200610-git.tgz
MD5 6f2eaaae3fb03ba719d77ed3ffaeaf4f NAME cl-ascii-table FILENAME
cl-ascii-table DEPS NIL DEPENDENCIES NIL VERSION 20200610-git SIBLINGS NIL
PARASITES NIL) */

44
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-async-repl.nix
View file

@ -1,44 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-async-repl";
version = "cl-async-20211020-git";
description = "REPL integration for CL-ASYNC.";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-async" args."cl-async-base" args."cl-async-util" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."vom" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz";
sha256 = "1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0";
};
packageName = "cl-async-repl";
asdFilesToKeep = ["cl-async-repl.asd"];
overrides = x: x;
}
/* (SYSTEM cl-async-repl DESCRIPTION REPL integration for CL-ASYNC. SHA256
1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0 URL
http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz
MD5 0e0cd11758e93a91b39ad726fb1051cc NAME cl-async-repl FILENAME
cl-async-repl DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi) (NAME cffi-grovel FILENAME cffi-grovel)
(NAME cffi-toolchain FILENAME cffi-toolchain)
(NAME cl-async FILENAME cl-async)
(NAME cl-async-base FILENAME cl-async-base)
(NAME cl-async-util FILENAME cl-async-util)
(NAME cl-libuv FILENAME cl-libuv) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME fast-io FILENAME fast-io)
(NAME static-vectors FILENAME static-vectors)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams)
(NAME vom FILENAME vom))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cffi-grovel cffi-toolchain cl-async
cl-async-base cl-async-util cl-libuv cl-ppcre fast-io static-vectors
trivial-features trivial-gray-streams vom)
VERSION cl-async-20211020-git SIBLINGS
(cl-async-ssl cl-async-test cl-async) PARASITES NIL) */

45
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-async-ssl.nix
View file

@ -1,45 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-async-ssl";
version = "cl-async-20211020-git";
description = "SSL Wrapper around cl-async socket implementation.";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-async" args."cl-async-base" args."cl-async-util" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."vom" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz";
sha256 = "1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0";
};
packageName = "cl-async-ssl";
asdFilesToKeep = ["cl-async-ssl.asd"];
overrides = x: x;
}
/* (SYSTEM cl-async-ssl DESCRIPTION
SSL Wrapper around cl-async socket implementation. SHA256
1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0 URL
http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz
MD5 0e0cd11758e93a91b39ad726fb1051cc NAME cl-async-ssl FILENAME
cl-async-ssl DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi) (NAME cffi-grovel FILENAME cffi-grovel)
(NAME cffi-toolchain FILENAME cffi-toolchain)
(NAME cl-async FILENAME cl-async)
(NAME cl-async-base FILENAME cl-async-base)
(NAME cl-async-util FILENAME cl-async-util)
(NAME cl-libuv FILENAME cl-libuv) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME fast-io FILENAME fast-io)
(NAME static-vectors FILENAME static-vectors)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams)
(NAME vom FILENAME vom))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cffi-grovel cffi-toolchain cl-async
cl-async-base cl-async-util cl-libuv cl-ppcre fast-io static-vectors
trivial-features trivial-gray-streams vom)
VERSION cl-async-20211020-git SIBLINGS
(cl-async-repl cl-async-test cl-async) PARASITES NIL) */

42
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-async.nix
View file

@ -1,42 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-async";
version = "20211020-git";
parasites = [ "cl-async-base" "cl-async-util" ];
description = "Asynchronous operations for Common Lisp.";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."uiop" args."vom" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz";
sha256 = "1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0";
};
packageName = "cl-async";
asdFilesToKeep = ["cl-async.asd"];
overrides = x: x;
}
/* (SYSTEM cl-async DESCRIPTION Asynchronous operations for Common Lisp. SHA256
1b3bwqvzw2pc83m4x8vbbxyriq58g0j3738mzq68v689zl071dl0 URL
http://beta.quicklisp.org/archive/cl-async/2021-10-20/cl-async-20211020-git.tgz
MD5 0e0cd11758e93a91b39ad726fb1051cc NAME cl-async FILENAME cl-async DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi) (NAME cffi-grovel FILENAME cffi-grovel)
(NAME cffi-toolchain FILENAME cffi-toolchain)
(NAME cl-libuv FILENAME cl-libuv) (NAME cl-ppcre FILENAME cl-ppcre)
(NAME fast-io FILENAME fast-io)
(NAME static-vectors FILENAME static-vectors)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-gray-streams FILENAME trivial-gray-streams)
(NAME uiop FILENAME uiop) (NAME vom FILENAME vom))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cffi-grovel cffi-toolchain cl-libuv
cl-ppcre fast-io static-vectors trivial-features trivial-gray-streams uiop
vom)
VERSION 20211020-git SIBLINGS (cl-async-repl cl-async-ssl cl-async-test)
PARASITES (cl-async-base cl-async-util)) */

29
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-base64.nix
View file

@ -1,29 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-base64";
version = "20201016-git";
parasites = [ "cl-base64/test" ];
description = "Base64 encoding and decoding with URI support.";
deps = [ args."kmrcl" args."ptester" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-base64/2020-10-16/cl-base64-20201016-git.tgz";
sha256 = "1wd2sgvfrivrbzlhs1vgj762jqz7sk171ssli6gl1kfwbnphzx9z";
};
packageName = "cl-base64";
asdFilesToKeep = ["cl-base64.asd"];
overrides = x: x;
}
/* (SYSTEM cl-base64 DESCRIPTION Base64 encoding and decoding with URI support.
SHA256 1wd2sgvfrivrbzlhs1vgj762jqz7sk171ssli6gl1kfwbnphzx9z URL
http://beta.quicklisp.org/archive/cl-base64/2020-10-16/cl-base64-20201016-git.tgz
MD5 f556f7c61f785c84abdc1beb63c906ae NAME cl-base64 FILENAME cl-base64 DEPS
((NAME kmrcl FILENAME kmrcl) (NAME ptester FILENAME ptester)) DEPENDENCIES
(kmrcl ptester) VERSION 20201016-git SIBLINGS NIL PARASITES
(cl-base64/test)) */

40
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-cairo.nix
View file

@ -1,40 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-cairo";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding to Cairo";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."iterate" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-cairo";
asdFilesToKeep = ["cl-cffi-gtk-cairo.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-cairo DESCRIPTION A Lisp binding to Cairo SHA256
15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-cairo FILENAME
cl-cffi-gtk-cairo DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi)
(NAME cl-cffi-gtk-glib FILENAME cl-cffi-gtk-glib)
(NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cl-cffi-gtk-glib iterate
trivial-features)
VERSION cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib cl-cffi-gtk-demo-gobject
cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo cl-cffi-gtk-gdk-pixbuf
cl-cffi-gtk-gdk cl-cffi-gtk-gio cl-cffi-gtk-glib cl-cffi-gtk-gobject
cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

42
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-gdk-pixbuf.nix
View file

@ -1,42 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-gdk-pixbuf";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding to GDK Pixbuf 2";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-gdk-pixbuf";
asdFilesToKeep = ["cl-cffi-gtk-gdk-pixbuf.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-gdk-pixbuf DESCRIPTION A Lisp binding to GDK Pixbuf 2
SHA256 15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-gdk-pixbuf FILENAME
cl-cffi-gtk-gdk-pixbuf DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi)
(NAME cl-cffi-gtk-glib FILENAME cl-cffi-gtk-glib)
(NAME cl-cffi-gtk-gobject FILENAME cl-cffi-gtk-gobject)
(NAME closer-mop FILENAME closer-mop) (NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-garbage FILENAME trivial-garbage))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cl-cffi-gtk-glib
cl-cffi-gtk-gobject closer-mop iterate trivial-features trivial-garbage)
VERSION cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-cairo cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib
cl-cffi-gtk-demo-gobject cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo
cl-cffi-gtk-gdk cl-cffi-gtk-gio cl-cffi-gtk-glib cl-cffi-gtk-gobject
cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

48
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-gdk.nix
View file

@ -1,48 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-gdk";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding to GDK 3";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-gdk-pixbuf" args."cl-cffi-gtk-gio" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."cl-cffi-gtk-pango" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-gdk";
asdFilesToKeep = ["cl-cffi-gtk-gdk.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-gdk DESCRIPTION A Lisp binding to GDK 3 SHA256
15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-gdk FILENAME
cl-cffi-gtk-gdk DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi)
(NAME cl-cffi-gtk-cairo FILENAME cl-cffi-gtk-cairo)
(NAME cl-cffi-gtk-gdk-pixbuf FILENAME cl-cffi-gtk-gdk-pixbuf)
(NAME cl-cffi-gtk-gio FILENAME cl-cffi-gtk-gio)
(NAME cl-cffi-gtk-glib FILENAME cl-cffi-gtk-glib)
(NAME cl-cffi-gtk-gobject FILENAME cl-cffi-gtk-gobject)
(NAME cl-cffi-gtk-pango FILENAME cl-cffi-gtk-pango)
(NAME closer-mop FILENAME closer-mop) (NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-garbage FILENAME trivial-garbage))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cl-cffi-gtk-cairo
cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gio cl-cffi-gtk-glib
cl-cffi-gtk-gobject cl-cffi-gtk-pango closer-mop iterate trivial-features
trivial-garbage)
VERSION cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-cairo cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib
cl-cffi-gtk-demo-gobject cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo
cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gio cl-cffi-gtk-glib
cl-cffi-gtk-gobject cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

42
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-gio.nix
View file

@ -1,42 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-gio";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding to GIO 2";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-gio";
asdFilesToKeep = ["cl-cffi-gtk-gio.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-gio DESCRIPTION A Lisp binding to GIO 2 SHA256
15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-gio FILENAME
cl-cffi-gtk-gio DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi)
(NAME cl-cffi-gtk-glib FILENAME cl-cffi-gtk-glib)
(NAME cl-cffi-gtk-gobject FILENAME cl-cffi-gtk-gobject)
(NAME closer-mop FILENAME closer-mop) (NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-garbage FILENAME trivial-garbage))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cl-cffi-gtk-glib
cl-cffi-gtk-gobject closer-mop iterate trivial-features trivial-garbage)
VERSION cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-cairo cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib
cl-cffi-gtk-demo-gobject cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo
cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gdk cl-cffi-gtk-glib
cl-cffi-gtk-gobject cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

37
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-glib.nix
View file

@ -1,37 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-glib";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding to GLib 2";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."iterate" args."trivial-features" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-glib";
asdFilesToKeep = ["cl-cffi-gtk-glib.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-glib DESCRIPTION A Lisp binding to GLib 2 SHA256
15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-glib FILENAME
cl-cffi-gtk-glib DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi) (NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi iterate trivial-features) VERSION
cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-cairo cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib
cl-cffi-gtk-demo-gobject cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo
cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gdk cl-cffi-gtk-gio cl-cffi-gtk-gobject
cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

41
pkgs/development/lisp-modules-obsolete/quicklisp-to-nix-output/cl-cffi-gtk-gobject.nix
View file

@ -1,41 +0,0 @@
/* Generated file. */
args @ { fetchurl, ... }:
rec {
baseName = "cl-cffi-gtk-gobject";
version = "cl-cffi-gtk-20201220-git";
description = "A Lisp binding GObject 2";
deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
src = fetchurl {
url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz";
sha256 = "15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1";
};
packageName = "cl-cffi-gtk-gobject";
asdFilesToKeep = ["cl-cffi-gtk-gobject.asd"];
overrides = x: x;
}
/* (SYSTEM cl-cffi-gtk-gobject DESCRIPTION A Lisp binding GObject 2 SHA256
15vc0d7nirh0m6rkvzby2zb7qcpyvsxzs5yw5h6h3madyl8qm9b1 URL
http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-12-20/cl-cffi-gtk-20201220-git.tgz
MD5 954beac0970a46263153c2863ad1cb5f NAME cl-cffi-gtk-gobject FILENAME
cl-cffi-gtk-gobject DEPS
((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel)
(NAME bordeaux-threads FILENAME bordeaux-threads)
(NAME cffi FILENAME cffi)
(NAME cl-cffi-gtk-glib FILENAME cl-cffi-gtk-glib)
(NAME closer-mop FILENAME closer-mop) (NAME iterate FILENAME iterate)
(NAME trivial-features FILENAME trivial-features)
(NAME trivial-garbage FILENAME trivial-garbage))
DEPENDENCIES
(alexandria babel bordeaux-threads cffi cl-cffi-gtk-glib closer-mop iterate
trivial-features trivial-garbage)
VERSION cl-cffi-gtk-20201220-git SIBLINGS
(cl-cffi-gtk-cairo cl-cffi-gtk-demo-cairo cl-cffi-gtk-demo-glib
cl-cffi-gtk-demo-gobject cl-cffi-gtk-example-gtk cl-cffi-gtk-opengl-demo
cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gdk cl-cffi-gtk-gio cl-cffi-gtk-glib
cl-cffi-gtk cl-cffi-gtk-pango)
PARASITES NIL) */

Some files were not shown because too many files have changed in this diff Show more