me
/
guix
Archived
1
0
Fork 0
This repository has been archived on 2024-08-07. You can view files and clone it, but cannot push or open issues/pull-requests.
guix/gnu/packages/lisp.scm

281 lines
12 KiB
Scheme
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 John Darrington <jmd@gnu.org>
;;; Copyright © 2015 Taylan Ulrich Bayırlı/Kammer <taylanbayirli@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (gnu packages lisp)
#:use-module (gnu packages)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (gnu packages readline)
#:use-module (gnu packages texinfo)
#:use-module (gnu packages texlive)
#:use-module (gnu packages m4)
#:use-module (guix download)
#:use-module (guix utils)
#:use-module (guix build-system gnu)
#:use-module (gnu packages which)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages bdw-gc)
#:use-module (gnu packages libffi)
#:use-module (gnu packages libffcall)
#:use-module (gnu packages readline)
#:use-module (gnu packages libsigsegv)
#:use-module (gnu packages admin)
#:use-module (gnu packages ed))
(define-public gcl
(package
(name "gcl")
(version "2.6.12")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://gnu/" name "/" name "-" version ".tar.gz"))
(sha256
(base32 "1s4hs2qbjqmn9h88l4xvsifq5c3dlc5s74lyb61rdi5grhdlkf4f"))))
(build-system gnu-build-system)
(arguments
`(#:parallel-build? #f ; The build system seems not to be thread safe.
#:tests? #f ; There does not seem to be make check or anything similar.
#:configure-flags '("--enable-ansi") ; required for use by the maxima package
#:phases (alist-cons-before
'configure 'pre-conf
(lambda _
;; Patch bug when building readline support. This bug was
;; also observed by Debian
;; https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=741819
(substitute* "o/gcl_readline.d"
(("rl_attempted_completion_function = \\(CPPFunction \\*\\)rl_completion;")
"rl_attempted_completion_function = rl_completion;"))
(substitute*
(append
'("pcl/impl/kcl/makefile.akcl"
"add-defs"
"unixport/makefile.dos"
"add-defs.bat"
"gcl-tk/makefile.prev"
"add-defs1")
(find-files "h" "\\.defs"))
(("SHELL=/bin/(ba)?sh")
(string-append "SHELL=" (which "bash")))))
;; drop strip phase to make maxima build, see
;; https://www.ma.utexas.edu/pipermail/maxima/2008/009769.html
(alist-delete 'strip
%standard-phases))))
(native-inputs
`(("m4" ,m4)
("readline" ,readline)
("texinfo" ,texinfo)
("texlive" ,texlive)))
(home-page "http://www.gnu.org/software/gcl")
(synopsis "A Common Lisp implementation")
(description "GCL is an implementation of the Common Lisp language. It
features the ability to compile to native object code and to load native
object code modules directly into its lisp core. It also features a
stratified garbage collection strategy, a source-level debugger and a built-in
interface to the Tk widget system.")
(license license:lgpl2.0+)))
(define-public ecl
(package
(name "ecl")
(version "13.5.1")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://sourceforge/ecls/ecls/"
(version-major+minor version)
"/ecl-" version ".tgz"))
(sha256
(base32 "18ic8w9sdl0dh3kmyc9lsrafikrd9cg1jkhhr25p9saz0v75f77r"))))
(build-system gnu-build-system)
(native-inputs `(("which" ,which)))
(inputs `(("gmp" ,gmp)
("libatomic-ops" ,libatomic-ops)
("libgc" ,libgc)
("libffi" ,libffi)))
(arguments
'(#:phases
;; The test-suite seems to assume that ECL is installed. So re-order
;; the phases, then reference the installed executable.
(let* ((check-phase (assq-ref %standard-phases 'check))
(rearranged-phases
(alist-cons-after 'install 'check check-phase
(alist-delete 'check %standard-phases))))
(alist-cons-before
'check 'pre-check
(lambda* (#:key outputs #:allow-other-keys)
(substitute* '("build/tests/Makefile")
(("ECL=ecl")
(string-append
"ECL=" (assoc-ref outputs "out") "/bin/ecl"))))
rearranged-phases))
;; Parallel builds explicitly not supported:
;; http://sourceforge.net/p/ecls/bugs/98/
#:parallel-build? #f
#:parallel-tests? #f))
(home-page "http://ecls.sourceforge.net/")
(synopsis "Embeddable Common Lisp")
(description "ECL is an implementation of the Common Lisp language as
defined by the ANSI X3J13 specification. Its most relevant features are: a
bytecode compiler and interpreter, being able to compile Common Lisp with any
C/C++ compiler, being able to build standalone executables and libraries, and
supporting ASDF, Sockets, Gray streams, MOP, and other useful components.")
;; Note that the file "Copyright" points to some files and directories
;; which aren't under the lgpl2.0+ and instead contain many different,
;; non-copyleft licenses.
(license license:lgpl2.0+)))
(define-public clisp
(package
(name "clisp")
(version "2.49")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://gnu/clisp/release/" version
"/clisp-" version ".tar.gz"))
(sha256
(base32 "0rp82nqp5362isl9i34rwgg04cidz7izljd9d85pqcw1qr964bxx"))))
(build-system gnu-build-system)
(inputs `(("libffcall" ,libffcall)
("readline" ,readline)
("libsigsegv" ,libsigsegv)))
(arguments
'(#:phases
(alist-cons-after
'unpack 'patch-sh-and-pwd
(lambda _
;; The package is very messy with its references to "/bin/sh" and
;; some other absolute paths to traditional tools. These appear in
;; many places where our automatic patching misses them. Therefore
;; we do the following, in this early (post-unpack) phase, to solve
;; the problem from its root.
(substitute* (find-files "." "configure|Makefile")
(("/bin/sh") "sh"))
(substitute* '("src/clisp-link.in")
(("/bin/pwd") "pwd")))
(alist-cons-before
'build 'chdir-to-source
(lambda _
;; We are supposed to call make under the src sub-directory.
(chdir "src"))
%standard-phases))
;; Makefiles seem to have race conditions.
#:parallel-build? #f))
(home-page "http://www.clisp.org/")
(synopsis "Common Lisp implementation")
(description "GNU CLISP is an implementation of ANSI Common Lisp, with
many extensions. It includes an interpreter, compiler, debugger, CLOS, MOP,
an FFI, i18n, POSIX and Perl regular expressions, a socket interface, fast
bignums, arbitrary precision floats, and more. An X11 interface is available
through CLX, Garnet and CLUE/CLIO. Command line editing is provided by
readline.")
;; Website says gpl2+, COPYRIGHT file says gpl2; actual source files have
;; a lot of gpl3+. (Also some parts are under non-copyleft licenses, such
;; as CLX by Texas Instruments.) In that case gpl3+ wins out.
(license license:gpl3+)))
(define-public sbcl
(package
(name "sbcl")
(version "1.2.8")
(source
(origin
(method url-fetch)
(uri (string-append "mirror://sourceforge/sbcl/sbcl/" version "/sbcl-"
version "-source.tar.bz2"))
(sha256
(base32 "0ab9lw056yf6y0rjmx3iirn5n59pmssqxf00fbmpyl6qsnpaja1d"))))
(build-system gnu-build-system)
;; Bootstrap with CLISP.
(native-inputs
`(("clisp" ,clisp)
("which" ,which)
("inetutils" ,inetutils) ;for hostname(1)
("ed" ,ed)))
(arguments
'(#:phases
(alist-delete
'configure
(alist-cons-before
'build 'patch-unix-tool-paths
(lambda* (#:key outputs inputs #:allow-other-keys)
(let ((out (assoc-ref outputs "out"))
(bash (assoc-ref inputs "bash"))
(coreutils (assoc-ref inputs "coreutils"))
(ed (assoc-ref inputs "ed")))
(define (quoted-path input path)
(string-append "\"" input path "\""))
;; Patch absolute paths in string literals. Note that this
;; occurs in some .sh files too (which contain Lisp code).
(substitute* (find-files "." "\\.(lisp|sh)$")
(("\"/bin/sh\"") (quoted-path bash "/bin/sh"))
(("\"/usr/bin/env\"") (quoted-path coreutils "/usr/bin/env"))
(("\"/bin/cat\"") (quoted-path coreutils "/bin/cat"))
(("\"/bin/ed\"") (quoted-path ed "/bin/ed"))
(("\"/bin/echo\"") (quoted-path coreutils "/bin/echo"))
(("\"/bin/uname\"") (quoted-path coreutils "/bin/uname")))
;; This one script has a non-string occurrence of /bin/sh.
(substitute* '("tests/foreign.test.sh")
;; Leave whitespace so we don't match the shebang.
((" /bin/sh ") " sh "))
;; This file contains a module that can create executable files
;; which depend on the presence of SBCL. It generates shell
;; scripts doing "exec sbcl ..." to achieve this. We patch both
;; the shebang and the reference to "sbcl", tying the generated
;; executables to the exact SBCL package that generated them.
(substitute* '("contrib/sb-executable/sb-executable.lisp")
(("/bin/sh") (string-append bash "/bin/sh"))
(("exec sbcl") (string-append "exec " out "/bin/sbcl")))
;; Disable some tests that fail in our build environment.
(substitute* '("contrib/sb-bsd-sockets/tests.lisp")
;; This requires /etc/protocols.
(("\\(deftest get-protocol-by-name/error" all)
(string-append "#+nil ;disabled by Guix\n" all)))
(substitute* '("contrib/sb-posix/posix-tests.lisp")
;; These assume some users/groups which we don't have.
(("\\(deftest pwent\\.[12]" all)
(string-append "#+nil ;disabled by Guix\n" all))
(("\\(deftest grent\\.[12]" all)
(string-append "#+nil ;disabled by Guix\n" all)))))
(alist-replace
'build
(lambda* (#:key outputs #:allow-other-keys)
(setenv "CC" "gcc")
(zero? (system* "sh" "make.sh" "clisp"
(string-append "--prefix="
(assoc-ref outputs "out")))))
(alist-replace
'install
(lambda _
(zero? (system* "sh" "install.sh")))
%standard-phases))))
;; No 'check' target, though "make.sh" (build phase) runs tests.
#:tests? #f))
(home-page "http://www.sbcl.org/")
(synopsis "Common Lisp implementation")
(description "Steel Bank Common Lisp (SBCL) is a high performance Common
Lisp compiler. In addition to the compiler and runtime system for ANSI Common
Lisp, it provides an interactive environment including a debugger, a
statistical profiler, a code coverage tool, and many other extensions.")
;; Public domain in jurisdictions that allow it, bsd-2 otherwise. MIT
;; loop macro has its own license. See COPYING file for further notes.
(license (list license:public-domain license:bsd-2
(license:x11-style "file://src/code/loop.lisp")))))