pool/clisp
SHA256
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

.

Browse Source 
OBS-URL: https://build.opensuse.org/package/show/devel:languages:misc/clisp?expand=0&rev=148
This commit is contained in:
Dr. Werner Fink 2024-11-25 09:24:54 +00:00 committed by Git OBS Bridge
commit 83ecb6c1fd
19 changed files with 2436 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.gitattributes vendored Normal file
View File

@ -0,0 +1,23 @@
## Default LFS
*.7z filter=lfs diff=lfs merge=lfs -text
*.bsp filter=lfs diff=lfs merge=lfs -text
*.bz2 filter=lfs diff=lfs merge=lfs -text
*.gem filter=lfs diff=lfs merge=lfs -text
*.gz filter=lfs diff=lfs merge=lfs -text
*.jar filter=lfs diff=lfs merge=lfs -text
*.lz filter=lfs diff=lfs merge=lfs -text
*.lzma filter=lfs diff=lfs merge=lfs -text
*.obscpio filter=lfs diff=lfs merge=lfs -text
*.oxt filter=lfs diff=lfs merge=lfs -text
*.pdf filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
*.rpm filter=lfs diff=lfs merge=lfs -text
*.tbz filter=lfs diff=lfs merge=lfs -text
*.tbz2 filter=lfs diff=lfs merge=lfs -text
*.tgz filter=lfs diff=lfs merge=lfs -text
*.ttf filter=lfs diff=lfs merge=lfs -text
*.txz filter=lfs diff=lfs merge=lfs -text
*.whl filter=lfs diff=lfs merge=lfs -text
*.xz filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.zst filter=lfs diff=lfs merge=lfs -text

1
.gitignore vendored Normal file
View File

@ -0,0 +1 @@
.osc

34
README.SUSE Normal file
View File

@ -0,0 +1,34 @@
#
# (C) 1997-99, SuSE GmbH, Nürnberg
#
Call of CLX
Please call clisp with the option '-K full' to use clx. The
X Window System is required for the usage of clx. Therefore the clisp
version under /usr/lib/clisp/full/ is used.
For some examples of clx try out in the directory demos/
clisp -K full -q -i sokoban
and
clisp -K full -q -i qix
----------------------------------------------------------------------------
Aufruf von CLX
Bitte rufen Sie clisp mit der Option '-K full' auf. CLX erfordert ein
installiertes X-Window-System. Daher wird die entsprechende clisp-Version
aus /usr/lib/clisp/full/ benutzt.
Sie finden zwei Beispiele für clx im Verzeichnis demos/
clisp -K full -q -i sokoban
und
clisp -K full -q -i qix

43
check-build.sh Normal file
View File

@ -0,0 +1,43 @@
#!/bin/bash
#
# Copyright (c) 2006 SUSE LINUX Products GmbH, Nuernberg, Germany.
# This file and all modifications and additions to the pristine
# package are under the same license as the package itself.
#
# This script use the following variable(s):
#
# - $BUILD_BASENAME
#
case $BUILD_BASENAME in
*ia64)
read -t 10 name dummy version rest < /proc/version
if test -z "$version" ; then
echo "FATAL: can not read /proc/version" 1>&2
exit 1
fi
OIFS="$IFS"
IFS='.-'
version=($version)
IFS="$OIFS"
if test ${version[0]} -lt 2 -o ${version[1]} -lt 6 -o ${version[2]} -lt 16 ; then
echo "FATAL: kernel too old, need kernel >= 2.6.16 for this package" 1>&2
exit 1
fi
;;
*)
;;
esac
#
# XEN kernel may use different stack addresse range
#
if test -e /proc/xen; then
echo "FATAL: kernel contains xen support!" 1>&2
exit 1
fi
#
# Success
#
exit 0

142
clhs.el Normal file
View File

@ -0,0 +1,142 @@
;;; clhs.el -- access the Common Lisp HyperSpec (CLHS)
;;; this works with both
;;; * the "long file name" version released by Harlequin and available
;;; at the MIT web site as
;;; <http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/FrontMatter/> and
;;; * the "8.3 file name" version released later by Xanalys and available at
;;; <http://www.xanalys.com/software_tools/reference/HyperSpec/>
;;; and downloadable as
;;; <http://www.xanalys.com/software_tools/reference/HyperSpec/HyperSpec-6-0.tar.gz>
;;; This is accomplished by not hard-wiring the symbol->file table
;;; but reading the Data/<map> file instead
;;; Copyright (C) 2002-2008, 2017 Sam Steingold <sds@gnu.org>
;;; Keywords: lisp, common lisp, emacs, ANSI CL, hyperspec
;;; released under the GNU GPL <http://www.gnu.org/copyleft/gpl.html>
;;; as a part of GNU CLISP <http://clisp.cons.org>, <http://www.clisp.org>
;;; Commentary:
;; Kent Pitman and the Harlequin Group (later Xanalys) have made the
;; text of the "American National Standard for Information Technology --
;; Programming Language -- Common Lisp", ANSI X3.226-1994 available on
;; the WWW, in the form of the Common Lisp HyperSpec. This package
;; makes it convenient to peruse this documentation from within Emacs.
;; This is inspired by the Erik Naggum's version of 1997.
;;; Code:
(eval-when-compile (require 'cl)) ; push
(require 'browse-url)
(require 'thingatpt)
(require 'url)
(defcustom common-lisp-hyperspec-root "http://clhs.lisp.se/"
;; "http://www.lispworks.com/documentation/HyperSpec/"
;; "http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/html/hyperspec/HyperSpec/"
;; "http://www.ai.mit.edu/projects/iiip/doc/CommonLISP/HyperSpec/"
"*The root of the Common Lisp HyperSpec URL.
If you copy the HyperSpec to your local system, set this variable to
something like \"file:/usr/local/doc/HyperSpec/\"."
:group 'lisp
:type 'string)
(defvar clhs-history nil
"History of symbols looked up in the Common Lisp HyperSpec so far.")
(defvar clhs-symbols nil)
(defun clhs-table-buffer (&optional root)
(unless root (setq root common-lisp-hyperspec-root))
(if (string-match "^file:/" root)
(with-current-buffer (get-buffer-create " *clhs-tmp-buf*")
(insert-file-contents-literally
(let* ((d (concat (substring root 6) "/Data/"))
(f (concat d "Map_Sym.txt")))
(if (file-exists-p f) f
(setq f (concat d "Symbol-Table.text"))
(if (file-exists-p f) f
(error "no symbol table at %s" root))))
nil nil nil t)
(goto-char 0)
(current-buffer))
(let* ((d (concat root "/Data/"))
(f (concat d "Map_Sym.txt")))
(set-buffer (url-retrieve-synchronously f))
(goto-char 0)
(unless (looking-at "^HTTP/.*200 *OK$")
(kill-buffer (current-buffer))
(setq f (concat d "Symbol-Table.text"))
(set-buffer (url-retrieve-synchronously f))
(goto-char 0)
(unless (looking-at "^HTTP/.*200 *OK$")
(kill-buffer (current-buffer))
(error "no symbol table at %s" root)))
;; skip to the first symbol
(search-forward "\n\n")
(current-buffer))))
(defun clhs-read-symbols ()
"read `clhs-symbols' from the current position in the current buffer"
(while (not (eobp))
(puthash (buffer-substring-no-properties ; symbol
(line-beginning-position) (line-end-position))
(progn (forward-line 1) ; file name
(buffer-substring-no-properties ; strip "../"
(+ 3 (line-beginning-position)) (line-end-position)))
clhs-symbols)
(forward-line 1)))
(defun clhs-symbols ()
"Get `clhs-symbols' from `common-lisp-hyperspec-root'."
(if (and clhs-symbols (not (= 0 (hash-table-count clhs-symbols))))
clhs-symbols
(with-current-buffer (clhs-table-buffer)
(unless clhs-symbols
(setq clhs-symbols (make-hash-table :test 'equal :size 1031)))
(clhs-read-symbols)
(kill-buffer (current-buffer))
clhs-symbols)))
(defun hash-table-complete (string table how)
"This makes it possible to use hash-tables with `completing-read'.
Actually, `completing-read' in Emacs 22 accepts hash-tables natively."
(let ((res nil) (st (upcase string)) (len (length string)))
(maphash (lambda (key val)
(when (and (<= len (length key))
(string= st (substring key 0 len)))
(push key res)))
table)
(if how
res ; `all-completions'
(if (cdr res)
(try-completion st (mapcar #'list res))
(if (string= st (car res))
t
(car res))))))
;;;###autoload
(defun common-lisp-hyperspec (symbol-name &optional kill)
"Browse the Common Lisp HyperSpec documentation for SYMBOL-NAME.
Finds the HyperSpec at `common-lisp-hyperspec-root'.
With prefix arg, save the URL in the `kill-ring' instead."
(interactive (list (let ((sym (thing-at-point 'symbol t))
(completion-ignore-case t))
(completing-read
"Look-up symbol in the Common Lisp HyperSpec: "
#'hash-table-complete (clhs-symbols)
t sym 'clhs-history))
current-prefix-arg))
(unless (= ?/ (aref common-lisp-hyperspec-root
(1- (length common-lisp-hyperspec-root))))
(setq common-lisp-hyperspec-root
(concat common-lisp-hyperspec-root "/")))
(let ((url (concat common-lisp-hyperspec-root
(gethash (upcase symbol-name) (clhs-symbols)))))
(if kill
(kill-new url)
(browse-url url))))
(provide 'clhs)

18
clisp-2.39-ia64-wooh.dif Normal file
View File

@ -0,0 +1,18 @@
---
tests/streams.tst | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/streams.tst b/tests/streams.tst
--- a/tests/streams.tst
+++ b/tests/streams.tst
@@ -1043,8 +1043,8 @@ T
(describe (make-array nil :element-type nil) s)))
T
-(stringp (with-output-to-string (s) (describe nil s)))
-T
+;(stringp (with-output-to-string (s) (describe nil s)))
+;T
;; https://sourceforge.net/p/clisp/bugs/396/
(let ((s "a b"))

174
clisp-2.49-clx_demos.dif Normal file
View File

@ -0,0 +1,174 @@
---
modules/clx/new-clx/demos/README | 4 +--
modules/clx/new-clx/demos/clx-demos.lisp | 2 -
modules/clx/new-clx/demos/koch.lisp | 29 +++++++++++++++++++++++++-
modules/clx/new-clx/demos/qix.lisp | 30 ++++++++++++++++++++++++++-
modules/clx/new-clx/demos/sokoban.lisp | 34 +++++++++++++++++++++++++++++--
5 files changed, 92 insertions(+), 7 deletions(-)
--- a/modules/clx/new-clx/demos/README
+++ b/modules/clx/new-clx/demos/README
@@ -3,8 +3,8 @@ Most came with the original CLX and has
Some are original with CLISP (notably sokoban).
To try them, do
-$ clisp -i clx-demos
+$ clisp -K full -i clx-demos
and read the instructions.
To try them all, one by one, do
-$ clisp -i clx-demos -x '(clx-demos:run-all-demos)'
+$ clisp -K full -i clx-demos -x '(clx-demos:run-all-demos)'
--- a/modules/clx/new-clx/demos/clx-demos.lisp
+++ b/modules/clx/new-clx/demos/clx-demos.lisp
@@ -13,7 +13,7 @@
(defparameter *demos*
;; (demo-name [package requirements])
- '((koch) (qix) (sokoban #:xpm) (greynetic) (petal) (hanoi)
+ '((greynetic) (petal) (hanoi)
(recurrence) (plaid) (clclock) (bball) (bwindow)))
(defmacro do-demos ((fun-var) &body body)
--- a/modules/clx/new-clx/demos/koch.lisp
+++ b/modules/clx/new-clx/demos/koch.lisp
@@ -5,7 +5,30 @@
;;; See http://www.gnu.org/copyleft/gpl.html
;;;
-(in-package :clx-demos)
+(defpackage "KOCH"
+ (:use "COMMON-LISP" "XLIB" "EXT")
+ (:import-from "SYS" "GETENV")
+ (:shadowing-import-from "XLIB" "CHAR-WIDTH") ; EXT has CHAR-WIDTH
+ (:export "KOCH"))
+
+(in-package :koch)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun x-host-display (&optional (disp (getenv "DISPLAY")))
+ "Parse the DISPLAY environment variable.
+Return 3 values: host, server, screen."
+ (if disp
+ (let* ((pos1 (position #\: disp))
+ (pos2 (and pos1 (position #\. disp :start pos1))))
+ (values (subseq disp 0 pos1)
+ (if pos1 (parse-integer (subseq disp (1+ pos1) pos2)) 0)
+ (if pos2 (parse-integer (subseq disp (1+ pos2))) 0)))
+ (values "" 0 0)))
+
+(defun x-open-display ()
+ "Open the appropriate X display."
+ (multiple-value-bind (host di) (x-host-display)
+ (xlib:open-display host :display di)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun koch-point (cx width/2 height/2 scale)
(list (round (+ width/2 (* scale width/2 (realpart cx))))
@@ -121,4 +144,8 @@ Returns the new list and an indicator of
(xlib:unmap-window win)
(xlib:display-finish-output dpy))))
+(format t "~& Koch snoflake:~%
+ (koch:koch :width :height :delay :x :y :scale :font)
+~% Call (koch:koch)~%~%")
+
(provide "koch")
--- a/modules/clx/new-clx/demos/qix.lisp
+++ b/modules/clx/new-clx/demos/qix.lisp
@@ -14,7 +14,30 @@
;;;; o or a spline option?!
;;;;
-(in-package :clx-demos)
+(defpackage "QIX"
+ (:use "COMMON-LISP" "XLIB" "EXT")
+ (:import-from "SYS" "GETENV")
+ (:shadowing-import-from "XLIB" "CHAR-WIDTH") ; EXT has CHAR-WIDTH
+ (:export "QIX"))
+
+(in-package :qix)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun x-host-display (&optional (disp (getenv "DISPLAY")))
+ "Parse the DISPLAY environment variable.
+Return 3 values: host, server, screen."
+ (if disp
+ (let* ((pos1 (position #\: disp))
+ (pos2 (and pos1 (position #\. disp :start pos1))))
+ (values (subseq disp 0 pos1)
+ (if pos1 (parse-integer (subseq disp (1+ pos1) pos2)) 0)
+ (if pos2 (parse-integer (subseq disp (1+ pos2))) 0)))
+ (values "" 0 0)))
+
+(defun x-open-display ()
+ "Open the appropriate X display."
+ (multiple-value-bind (host di) (x-host-display)
+ (xlib:open-display host :display di)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar *offset* 3)
(defvar *delta* 6)
@@ -87,4 +110,9 @@
(xlib:unmap-window win)
(xlib:display-finish-output dpy))))
+;; since we have no herald, simply dump it:
+(format t "~& The famous swirling vectors.~%
+ (qix:qix :host :display :dpy :width :height :delay :nqixs :nlines)
+~% Call (qix:qix) or (qix:qix :delay 0)~%~%")
+
(provide "qix")
--- a/modules/clx/new-clx/demos/sokoban.lisp
+++ b/modules/clx/new-clx/demos/sokoban.lisp
@@ -41,7 +41,30 @@
;;;; - maximum field size is hard wired to 20x20. (This is not in the LISP spirit!)
;;;; - sometimes the programm could not count correctly ...
-(in-package :clx-demos)
+(defpackage "SOKOBAN"
+ (:use "COMMON-LISP")
+ (:import-from "SYS" "GETENV")
+ (:import-from "XLIB" "CLOSED-DISPLAY-P")
+ (:export "SOKOBAN"))
+
+(in-package :sokoban)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun x-host-display (&optional (disp (getenv "DISPLAY")))
+ "Parse the DISPLAY environment variable.
+Return 3 values: host, server, screen."
+ (if disp
+ (let* ((pos1 (position #\: disp))
+ (pos2 (and pos1 (position #\. disp :start pos1))))
+ (values (subseq disp 0 pos1)
+ (if pos1 (parse-integer (subseq disp (1+ pos1) pos2)) 0)
+ (if pos2 (parse-integer (subseq disp (1+ pos2))) 0)))
+ (values "" 0 0)))
+
+(defun x-open-display ()
+ "Open the appropriate X display."
+ (multiple-value-bind (host di) (x-host-display)
+ (xlib:open-display host :display di)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; First a lot of global variables ...
(defvar *pixmaps* nil) ;array of pixmaps according to below indices
@@ -228,7 +251,12 @@
(nny (+ ny dy)))
(when (>= (field nnx nny) %floor)
;;Ok its legal ...
- (when (and (= (field nx ny) %object)
+ ;;Allow moving through
+ (when (and (= (field nx ny) %treasure)
+ (= (field nnx nny) %floor))
+ (incf *n-objects*))
+ ;;Take this point
+ (when (and (= (field nx ny) %object)
(= (field nnx nny) %goal))
(decf *n-objects*))
(incf (field nx ny) 4) ;remove object and add man
@@ -475,4 +503,6 @@ If you quit sokoban using 'q' the curren
(setq *level* 1)
(init-field))) )
+(format t "~&~% Call (sokoban:sokoban)~%~%")
+
(provide "sokoban")

198
clisp-2.49-configure.dif Normal file
View File

@ -0,0 +1,198 @@
---
clisp-2.49.93+git20240704.f5acef38/configure | 4 +-
clisp-2.49.93+git20240704.f5acef38/modules/clx/new-clx/Makefile.in | 2 -
clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure | 2 -
clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure.in | 2 -
clisp-2.49.93+git20240704.f5acef38/modules/libsvm/libsvm.lisp | 2 -
clisp-2.49.93+git20240704.f5acef38/src/lispbibl.d | 16 ++++++----
clisp-2.49.93+git20240704.f5acef38/src/makemake.in | 14 +++++++-
clisp-2.49.93+git20240704.f5acef38/utils/ccmp2c.c | 1
clisp-2.49.93+git20240704.f5acef38/utils/modprep.lisp | 2 -
9 files changed, 31 insertions(+), 14 deletions(-)
--- clisp-2.49.93+git20240704.f5acef38/configure
+++ clisp-2.49.93+git20240704.f5acef38/configure 2024-09-02 13:23:26.124850752 +0000
@@ -429,11 +429,11 @@ do
passnext=makemake ;;
--vimdir=* | --vimdi=* | --vimd=* | --vim=* | --vi=*)
- subdir_configure_args="$subdir_configure_args $arg"
+# subdir_configure_args="$subdir_configure_args $arg"
makemake_args="$makemake_args --vimdir="`getarg "$arg"` ;;
--vimdir | --vimdi | --vimd | --vim | --vi)
- subdir_configure_args="$subdir_configure_args $arg"
+# subdir_configure_args="$subdir_configure_args $arg"
makemake_args="$makemake_args --vimdir="
prev=vimdir
passnext=both ;;
--- clisp-2.49.93+git20240704.f5acef38/modules/clx/new-clx/Makefile.in
+++ clisp-2.49.93+git20240704.f5acef38/modules/clx/new-clx/Makefile.in 2024-09-02 13:23:26.124850752 +0000
@@ -18,7 +18,7 @@ distribdir =
### Custom defs.
CCMP2C = ../../ccmp2c
RM = rm -f
-WANTS = @WANTS@
+WANTS = @WANTS@ -I ../../
X_CFLAGS = @X_CFLAGS@
# default target: make the module
--- clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure
+++ clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure 2024-09-02 13:23:26.124850752 +0000
@@ -5526,7 +5526,7 @@ printf "%s\n" "$as_me: ${term_bold}** Li
-ac_fn_c_check_header_compile "$LINENO" "svm.h" "ac_cv_header_svm_h" "$ac_includes_default"
+ac_fn_c_check_header_compile "$LINENO" "libsvm/svm.h" "ac_cv_header_svm_h" "$ac_includes_default"
if test "x$ac_cv_header_svm_h" = xyes
then :
printf "%s\n" "#define HAVE_SVM_H 1" >>confdefs.h
--- clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure.in
+++ clisp-2.49.93+git20240704.f5acef38/modules/libsvm/configure.in 2024-09-02 13:23:26.124850752 +0000
@@ -16,7 +16,7 @@ AC_LIB_LINKFLAGS([svm])
BOLD_MSG([LibSVM (Headers)])
AC_SUBST(LIBSVM_CFLAGS)
AC_SUBST(LIBSVM_LIBS)
-AC_CHECK_HEADERS(svm.h)
+AC_CHECK_HEADERS([libsvm/svm.h])
if test "$ac_cv_header_svm_h" = "no"; then
AC_MSG_ERROR([cannot find LibSVM headers])
fi
--- clisp-2.49.93+git20240704.f5acef38/modules/libsvm/libsvm.lisp
+++ clisp-2.49.93+git20240704.f5acef38/modules/libsvm/libsvm.lisp 2024-09-02 13:23:26.124850752 +0000
@@ -15,7 +15,7 @@
(default-foreign-language :stdc)
-(c-lines "#include \"config.h\"~%#include <svm.h>~%")
+(c-lines "#include \"config.h\"~%#include <libsvm/svm.h>~%")
(defvar *libsvm-output* *standard-output* "The stream for svm.so messages.")
(cl:defun write-string-to-libsvm-output (s)
--- clisp-2.49.93+git20240704.f5acef38/src/lispbibl.d
+++ clisp-2.49.93+git20240704.f5acef38/src/lispbibl.d 2024-09-02 13:23:26.128850679 +0000
@@ -178,7 +178,7 @@
#define PC386 /* IBMPC-compatible with 80386/80486-processor */
#endif
#ifdef GENERIC_UNIX
- #if (defined(unix) && (defined(linux) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)) && (defined(i386) || defined(__i386__) || defined(__x86_64__) || defined(__amd64__)))
+ #if (defined(unix) && ((defined(linux) || defined(__linux__)) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)) && (defined(i386) || defined(__i386__) || defined(__x86_64__) || defined(__amd64__)))
#define PC386
#endif
#if (defined(sun) && defined(unix) && defined(sparc))
@@ -274,8 +274,14 @@
#endif
#ifdef GENERIC_UNIX
#define UNIX
- #ifdef __linux__
+ #if defined(__linux__) || defined(linux)
#define UNIX_LINUX /* Linux (Linus Torvalds Unix) */
+ #ifndef linux
+ #define linux
+ #endif
+ #ifndef __linux__
+ #define __linux__
+ #endif
#endif
#ifdef __GNU__
#define UNIX_HURD /* the GNU system (Hurd + glibc) */
@@ -1271,7 +1277,7 @@ typedef signed int signean;
address of its component 'ident' and return it as number: */
#include <stddef.h>
#ifndef offsetof
- #define offsetof(type,ident) ((ULONG)&(((type*)0)->ident))
+ #define offsetof(type,ident) ((size_t)&(((type*)0)->ident))
#endif
/* Determine the offset of an array 'ident' in a struct of the type 'type': */
#if defined(__cplusplus) || defined(MICROSOFT)
@@ -5439,9 +5445,9 @@ typedef signed_int_with_n_bits(intVsize)
type_data_object(type,data) */
#if defined(WIDE) && defined(WIDE_STRUCT)
#if BIG_ENDIAN_P==WIDE_ENDIANNESS
- #define type_data_object(type,data) ((object){{(tint)(type),(aint)(data)}INIT_ALLOCSTAMP})
+ #define type_data_object(type,data) (object){{(tint)(type),(aint)(data)}INIT_ALLOCSTAMP}
#else
- #define type_data_object(type,data) ((object){{(aint)(data),(tint)(type)}INIT_ALLOCSTAMP})
+ #define type_data_object(type,data) (object){{(aint)(data),(tint)(type)}INIT_ALLOCSTAMP}
#endif
#elif !(oint_addr_shift==0)
#define type_data_object(type,data) \
--- clisp-2.49.93+git20240704.f5acef38/src/makemake.in
+++ clisp-2.49.93+git20240704.f5acef38/src/makemake.in 2024-09-02 13:34:28.840613211 +0000
@@ -248,6 +248,9 @@ verbose=${CLISP_MAKEMAKE_VERBOSE:-false}
# Handle --with-... arguments
while test -z "$endofargs"; do
case "$1" in
+ -ignore* | --ignore* )
+ shift
+ ;;
-verb* | --verb* )
verbose=`echol "$1"|sed 's/-*v[^=]*=*//'`
test -n "${verbose}" || verbose=true
@@ -1166,11 +1169,13 @@ else
fi
# Main cpu dependencies:
+set -x
cpu="${host_cpu_c_abi}"
if test -z "$cpu"; then
echo "$0: WARNING: host_cpu_c_abi is void; using host_cpu=${host_cpu}" >&2
cpu="${host_cpu}"
fi
+set +x
test "${verbose}" = true -o "${verbose}" = yes && \
cat <<EOF >&2
@@ -1367,6 +1372,10 @@ if [ $XCC_GCC = true ] ; then
XCFLAGS=${XCFLAGS}" -pthread"
fi
+ if [ -n "${MYCFLAGS}" ] ; then
+ XCFLAGS=$XCFLAGS' ${MYCFLAGS}'
+ fi
+
else
if [ $CROSS = false ] ; then
@@ -1468,7 +1477,7 @@ if [ "${with_dynamic_modules}" != no ];
eval XCC_PICFLAG=\"${pic_flag}\"
if [ "$HSYSOS" != cygwin ]; then
eval "`./libtool --tag=CC --config | grep '^allow_undefined_flag='`"
- eval "`./libtool --tag=CC --config | grep '^archive_cmds='`"
+ eval "`./libtool --tag=CC --config | sed -rn '/^archive_cmds=/{ s/\s*-shared//; s/(\\\$compiler_flags)/\1 -shared/; p }'`"
else
archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname'
fi
@@ -4036,8 +4045,9 @@ if [ $CROSS = false ] ; then
echol
if [ "${with_dynamic_modules}" != no ]; then
depends="full install-modules force"
- line='linkkit base'
+ line='linkkit base full'
echol "install-modules : full force"
+ echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/full"
echotab "mkdir -p \$(DESTDIR)\$(lisplibdir)/dynmod"
echotab "DESTDIR=\`cd \"\$(DESTDIR)\$(lisplibdir)\"; pwd\` CLISP='./clisp -q -norc' ./clisp-link install \$(MODULES)"
echol
--- clisp-2.49.93+git20240704.f5acef38/utils/ccmp2c.c
+++ clisp-2.49.93+git20240704.f5acef38/utils/ccmp2c.c 2024-09-02 13:23:26.128850679 +0000
@@ -1042,6 +1042,7 @@ main (int argc, char *argv[])
infilename = argv[1];
/* Emit prologue. */
+ printf ("#include <config.h>\n");
printf ("#include <stdio.h>\n");
printf ("#include <stdlib.h>\n");
printf ("#include <string.h>\n");
--- clisp-2.49.93+git20240704.f5acef38/utils/modprep.lisp
+++ clisp-2.49.93+git20240704.f5acef38/utils/modprep.lisp 2024-09-02 13:23:26.128850679 +0000
@@ -328,7 +328,7 @@ FOO(bar,baz,zot) ==> FOO; (bar baz zot);
((or (char= cc #\_) (char= cc #\-)) (write-char #\_ out))
(t (format out "_~2,'0x" (char-code cc))))))
-(defvar *tag-length-limit* 2000
+(defvar *tag-length-limit* 4096
"The approximate maximum length of a C name.
This works around the failure on i18n on Alpha Linux:
/tmp/ccYZBYCX.s: Assembler messages:

13
clisp-2.49-gctoken.dif Normal file
View File

@ -0,0 +1,13 @@
diff --git a/utils/gctrigger.c b/utils/gctrigger.c
--- a/utils/gctrigger.c
+++ b/utils/gctrigger.c
@@ -606,6 +606,7 @@ static inline void VectorToken_delete (V
static Token nexttoken (boolean within_prep_directive)
{
Token token;
+ memset(&token, 0, sizeof(Token));
restart:
{ int c = next_char();
switch (c) {

32
clisp-2.49-personality.patch Normal file
View File

@ -0,0 +1,32 @@
---
src/_clisp.c | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/src/_clisp.c b/src/_clisp.c
--- a/src/_clisp.c
+++ b/src/_clisp.c
@@ -48,6 +48,11 @@
/* Declare stderr, perror(). */
# include <stdio.h>
+#if defined(HAS_PERSONALITY) && (HAS_PERSONALITY > 0)
+/* Declare syscall, PER_LINUX32. */
+# include <sys/personality.h>
+#endif
+
#if defined(WIN32_NATIVE)
# include <windows.h>
int shell_quote (char * dest, const char * source);
@@ -435,6 +440,12 @@ int main (int argc, char* argv[])
}
#undef W32ERR
#else
+#if defined(HAS_PERSONALITY) && (HAS_PERSONALITY > 0)
+ if (personality(PER_LINUX32)) {
+ perror(program_name);
+ return 1;
+ }
+#endif
execv(executable,new_argv);
{ /* execv() returns only if there was an error. */
int saved_errno = errno;

9
clisp-2.49-postgresql.dif Normal file
View File

@ -0,0 +1,9 @@
--- a/modules/postgresql/link.sh.in
+++ b/modules/postgresql/link.sh.in
@@ -4,5 +4,5 @@ ${MAKE-make} clisp-module \
NEW_MODULES='postgresql'
NEW_FILES=''
for f in ${NEW_MODULES}; do NEW_FILES=${NEW_FILES}" ${f}.o"; done
-NEW_LIBS="${NEW_FILES} @LIBS@"
+NEW_LIBS="${NEW_FILES} @LIBS@ -lcrypt -lssl"
TO_LOAD='postgresql sql'

3
clisp-2.49.93+git20240704.f5acef38.tar.xz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:6b7d512b12653ea022cc461308ecd36a6aae66473ae797fbcd37ba7b663e4fa4
size 7239936

31
clisp-db6.diff Normal file
View File

@ -0,0 +1,31 @@
From: Jan Engelhardt <jengelh@inai.de>
Date: 2013-06-14 13:55:00.148814697 +0200
Work around compile abort with libdb-6.0
BDB has removed RPC support (which was not implemented anyway;
it [set_rpc_server] always returned EOPNOTSUPP even in libdb-4.8).
---
clisp-536a48a9/modules/berkeley-db/bdb.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
--- clisp-536a48a9/modules/berkeley-db/bdb.c
+++ clisp-536a48a9/modules/berkeley-db/bdb.c 2016-11-29 11:58:23.833524665 +0000
@@ -60,6 +60,7 @@ static void vecout (unsigned char* v, in
this is a macro and not a function for NO_UNICODE */
#define asciz_to_string0(a,e) (a ? asciz_to_string(a,e) : NIL)
+#include <errno.h>
#include <db.h>
/* http://www.oracle.com/technology/products/berkeley-db/db/update/4.4.20/if.4.4.20.html
@@ -2216,7 +2217,7 @@ DEFUN(BDB:DB-COMPACT, db &key TRANSACTIO
c_data.compact_timeout = timeout;
c_data.compact_pages = pages;
SYSCALL(db->compact,(db,txn,pstart,pstop,&c_data,flags,&end));
- pushSTACK(uint32_to_I(c_data.compact_empty_buckets));
+/*pushSTACK(uint32_to_I(c_data.compact_empty_buckets));*/
pushSTACK(uint32_to_I(c_data.compact_pages_free));
pushSTACK(uint32_to_I(c_data.compact_pages_examine));
pushSTACK(uint32_to_I(c_data.compact_levels));

130
clisp-gcc14.patch Normal file
View File

@ -0,0 +1,130 @@
---
modules/berkeley-db/bdb.c | 11 ++++++-----
modules/berkeley-db/configure | 2 +-
modules/berkeley-db/configure.in | 2 +-
src/foreign.d | 2 +-
src/lispbibl.d | 2 +-
src/spvw_fault.d | 2 +-
src/spvw_language.d | 2 +-
src/spvw_sigsegv.d | 2 +-
8 files changed, 13 insertions(+), 12 deletions(-)
--- modules/berkeley-db/bdb.c
+++ modules/berkeley-db/bdb.c 2024-08-29 11:45:09.133249570 +0000
@@ -364,7 +364,7 @@ DEFUN(BDB:DBE-CREATE,&key PASSWORD ENCRY
dbe_set_encryption(dbe,&STACK_0,&STACK_1);
skipSTACK(2);
/* set error & message callbacks */
- begin_system_call(); dbe->set_errcall(dbe,&error_callback);
+ begin_system_call(); dbe->set_errcall(dbe,(void (*)(const DB_ENV *,const char *,const char *))&error_callback);
#if defined(HAVE_DB_ENV_SET_MSGCALL)
dbe->set_msgcall(dbe,&message_callback);
#endif
@@ -1212,7 +1212,7 @@ DEFUN(BDB:DB-CREATE, dbe)
SYSCALL(db_create,(&db,dbe,0));
if (!dbe) { /* set error callback */
begin_system_call();
- db->set_errcall(db,&error_callback);
+ db->set_errcall(db,(void (*)(const DB_ENV *,const char *,const char *))&error_callback);
end_system_call();
}
wrap_finalize(db,STACK_0,`BDB::MKDB`,``BDB::DB-CLOSE``);
@@ -1514,9 +1514,9 @@ DEFUN(BDB:DB-STAT, db &key FAST-STAT TRA
{ /* Return database statistics */
DB_TXN *txn = (DB_TXN*)bdb_handle(popSTACK(),`BDB::TXN`,BH_NIL_IS_NULL);
#if defined(HAVE_DB_STAT_ACCEPT_TXN)
-# define DB_STAT(s) SYSCALL(db->stat,(db,txn,&s,flags));
+# define DB_STAT(s) SYSCALL(db->stat,(db,txn,(void*)&s,flags));
#else
-# define DB_STAT(s) SYSCALL(db->stat,(db,&s,flags));
+# define DB_STAT(s) SYSCALL(db->stat,(db,(void*)&s,flags));
#endif
u_int32_t flags = missingp(STACK_0) ? 0 : DB_FAST_STAT;
DB *db = (DB*)bdb_handle(STACK_1,`BDB::DB`,BH_VALID);
@@ -2752,7 +2752,8 @@ DEFUN(BDB:TXN-RECOVER, dbe &key FIRST :N
DB_ENV *dbe = (DB_ENV*)bdb_handle(popSTACK(),`BDB::DBE`,BH_VALID);
u_int32_t tx_max;
DB_PREPLIST *preplist;
- int status, ii;
+ int status;
+ long ii;
u_int32_t retnum;
SYSCALL(dbe->get_tx_max,(dbe,&tx_max));
preplist = (DB_PREPLIST*)clisp_malloc(tx_max * sizeof(DB_PREPLIST));
--- modules/berkeley-db/configure.in
+++ modules/berkeley-db/configure.in 2024-08-29 07:17:20.463971573 +0000
@@ -38,7 +38,7 @@ AC_CHECK_SIZEOF(db_recno_t,,[#include <s
dnl <http://www.sleepycat.com/docs/ref/upgrade.4.3/stat.html>
AC_CACHE_CHECK([whether DB->stat() accepts TXNid],ac_cv_db_stat_accept_txn,[
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <db.h>],
-[[DB db; db.stat(&db,NULL,0,NULL);]])],
+[[DB db; db.stat(&db,NULL,NULL,0);]])],
ac_cv_db_stat_accept_txn=yes,ac_cv_db_stat_accept_txn=no)])
if test "$ac_cv_db_stat_accept_txn" = "yes"; then
AC_DEFINE(HAVE_DB_STAT_ACCEPT_TXN,1,[Define to 1 if DB->stat() accepts TXNid])
--- modules/berkeley-db/configure
+++ modules/berkeley-db/configure 2024-08-29 07:17:20.463971573 +0000
@@ -6241,7 +6241,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_
int
main (void)
{
-DB db; db.stat(&db,NULL,0,NULL);
+DB db; db.stat(&db,NULL,NULL,0);
;
return 0;
}
--- src/foreign.d
+++ src/foreign.d 2024-08-29 07:24:17.508412215 +0000
@@ -2417,7 +2417,7 @@ local void count_walk_post (object fvd,
{
unused(fvd); unused(obj); unused(walk);
}
-local maygc void convert_to_foreign_needs (object fvd, object obj,
+local maygc __attribute__((noinline)) void convert_to_foreign_needs (object fvd, object obj,
struct foreign_layout *sas)
{
struct walk_lisp walk
--- src/lispbibl.d
+++ src/lispbibl.d 2024-08-29 07:25:56.826610237 +0000
@@ -11641,7 +11641,7 @@ All other long words on the LISP-Stack a
#define FAST_SP
#endif
#elif defined(GNU) && defined(SP_register)
- register __volatile__ aint __SP __asm__(SP_register);
+ register aint __SP __asm__(SP_register);
#ifdef SPARC64
#define SP() (__SP+2048)
#else
--- src/spvw_fault.d
+++ src/spvw_fault.d 2024-08-29 07:20:02.297039630 +0000
@@ -289,7 +289,7 @@ modexp bool handle_fault_range (int prot
local void xmprotect (aint addr, uintM len, int prot) {
if (mprotect((void*)addr,len,prot) < 0) {
- fprintf(stderr,GETTEXTL("mprotect(0x%lx,%d,%d) failed."),addr,len,prot);
+ fprintf(stderr,GETTEXTL("mprotect(0x%lx,%lu,%d) failed."),addr,(unsigned long)len,prot);
errno_out(OS_errno);
abort();
}
--- src/spvw_language.d
+++ src/spvw_language.d 2024-08-29 07:20:29.048554790 +0000
@@ -172,7 +172,7 @@ global void init_language
{ /* Invalidate the gettext internal caches. */
char *td = textdomain(NULL);
if (NULL == td) {
- ANSIC_ERROR("textdomain",NULL);
+ ANSIC_ERROR("textdomain","");
}
if (NULL == textdomain(td)) {
ANSIC_ERROR("textdomain",td);
--- src/spvw_sigsegv.d
+++ src/spvw_sigsegv.d 2024-08-29 07:21:09.115828518 +0000
@@ -62,7 +62,7 @@ local void print_mem_stats (void) {
/* Put a breakpoint here if you want to catch CLISP just before it dies. */
global void sigsegv_handler_failed (void* address) {
fprint(stderr,"\n");
- fprintf(stderr,GETTEXTL("SIGSEGV cannot be cured. Fault address = 0x%lx."),
+ fprintf(stderr,GETTEXTL("SIGSEGV cannot be cured. Fault address = 0x%p."),
address);
fprint(stderr,"\n");
print_mem_stats();

36
clisp-link.dif Normal file
View File

@ -0,0 +1,36 @@
---
src/clisp-link.in | 2 +-
src/lispbibl.d | 4 +++-
2 files changed, 4 insertions(+), 2 deletions(-)
--- src/clisp-link.in
+++ src/clisp-link.in 2018-02-19 09:30:11.548748097 +0000
@@ -579,7 +579,7 @@ case "$1" in
# when running "CLISP=./clisp ./clisp-link install <modname>"
# in the build directory, avoid "cp: `...' and `...' are the same file"
if [ "${absolute_moduledir}" != "${absdestdir}/$moduledir" ]; then
- make clisp-module-distrib LN=${INSTALL_DATA-cp} distribdir="${absdestdir}/$moduledir"
+ make clisp-module-distrib LN="${INSTALL_DATA-cp}" distribdir="${absdestdir}/$moduledir"
mkdir -p ${absdestdir}/${DYNMOD};
for f in ${DYNDIR_FILES}; do
cp ${f} ${absdestdir}/${DYNMOD}/
--- src/lispbibl.d
+++ src/lispbibl.d 2018-02-19 09:30:11.552748021 +0000
@@ -1610,6 +1610,8 @@ typedef SLONG sint32; /* signed 32 bi
/* Emulate 64-Bit-numbers using two 32-Bit-numbers. */
typedef struct { sintL hi; uintL lo; } sintL2; /* signed 64 Bit integer */
typedef struct { uintL hi; uintL lo; } uintL2; /* unsigned 64 Bit integer */
+ #define bitQ(n) bit(n)
+ #define bitQm(n) bitm(n)
#endif
/* Use 'uintX' and 'sintX' for Integers with approximately given width
and a minumum of storage space. */
@@ -14188,7 +14190,7 @@ re-enters the corresponding top-level lo
#define pushSTACK(obj) (STACK_(-1) = (obj), STACK skipSTACKop -1)
/* Almost equivalent with *--STACK = obj resp. *STACK++ = obj , but
Careful: first enter the object into STACK_(-1), THEN modify the STACK! */
-#define popSTACK() (STACK skipSTACKop 1, STACK_(-1))
+#define popSTACK() ({STACK skipSTACKop 1; STACK_(-1);})
#define skipSTACK(n) (STACK skipSTACKop (sintP)(n))
#if defined(GNU) && defined(M68K) && !defined(NO_ASM) && !defined(WIDE) && defined(STACK_register)

16
clisp-linux.patch Normal file
View File

@ -0,0 +1,16 @@
---
modules/bindings/glibc/linux.lisp | 2 ++
1 file changed, 2 insertions(+)
diff --git a/modules/bindings/glibc/linux.lisp b/modules/bindings/glibc/linux.lisp
--- a/modules/bindings/glibc/linux.lisp
+++ b/modules/bindings/glibc/linux.lisp
@@ -294,6 +294,8 @@
;; for robust mutexes
(def-c-const EOWNERDEAD (:documentation "Owner died")) ; 130
(def-c-const ENOTRECOVERABLE (:documentation "State not recoverable")) ; 131
+(def-c-const ERFKILL (:documentation "Operation not possible due to RF-kill")) ; 132
+(def-c-const EHWPOISON (:documentation "Memory page has hardware error")) ; 133
; -------------------------- <bits/errno.h> -----------------------------------

6
clisp-rpmlintrc Normal file
View File

@ -0,0 +1,6 @@
addFilter(".*devel-file-in-non-devel-package.*/usr/lib.*/clisp-.*/.*")
addFilter(".*make-check-outside-check-section.*make\ check.*")
addFilter(".*executable-stack.*/usr/lib.*/clisp-.*")
addFilter(".*binary-or-shlib-calls-gethostbyname.*/usr/lib.*/clisp-.*")
addFilter(".*file-contains-date-and-time.*/usr/lib.*/clisp-.*")
addFilter(".*position-independent-executable-suggested.*")

1107
clisp.changes Normal file
View File

File diff suppressed because it is too large Load Diff

420
clisp.spec Normal file
View File

@ -0,0 +1,420 @@
#
# spec file for package clisp
#
# Copyright (c) 2024 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.
# Please submit bugfixes or comments via https://bugs.opensuse.org/
#
%bcond_with debug
%global commit f5acef38
%global vdate 20240704
Name: clisp
Version: 2.49.93
Release: 0
Summary: A Common Lisp Interpreter
# Included gllib is GPL-3.0-or-later
License: GPL-2.0-or-later AND GPL-3.0-or-later
Group: Development/Languages/Other
URL: https://gitlab.com/gnu-clisp/clisp
Source: %{name}-%{version}+git%{vdate}.%{commit}.tar.xz
Source2: clhs.el
Source3: clisp-rpmlintrc
Source4: README.SUSE
# PATCH-EXTEND-OPENSUSE Set the process execution domain
Patch1: clisp-2.49-personality.patch
# PATCH-FIX-OPENSUSE Fix crash on Ia64
Patch2: clisp-2.39-ia64-wooh.dif
# PATCH-EXTEND-OPENSUSE Make sure to be able to use MYCLFAGS
Patch4: clisp-2.49-configure.dif
# PATCH-FIX-OPENSUSE Make sure to use initialized token on garbage collection
Patch5: clisp-2.49-gctoken.dif
# PATCH-FEATURE-OPENSUSE Make CLX demos usable at runtime
Patch6: clisp-2.49-clx_demos.dif
# PATCH-EXTEND-OPENSUSE Enable postgresql SSL feature
Patch7: clisp-2.49-postgresql.dif
# PATCH-FIX-OPENSUSE Correct path for header for System V IPC system calls
Patch12: clisp-linux.patch
Patch13: clisp-gcc14.patch
Patch14: clisp-link.dif
Patch16: clisp-db6.diff
%global vimdir %{_datadir}/vim/site/after/syntax
BuildRequires: FastCGI-devel
BuildRequires: db-devel
BuildRequires: dbus-1-devel
BuildRequires: fdupes
BuildRequires: ffcall
#%ifarch s390x
#BuildRequires: gcc8
#%endif
BuildRequires: gdbm-devel
BuildRequires: glib2-devel
BuildRequires: groff
BuildRequires: gtk2-devel
BuildRequires: libglade2-devel
BuildRequires: libsigsegv-devel
BuildRequires: libsvm-devel
BuildRequires: ncurses-devel
BuildRequires: net-tools
BuildRequires: openssl-devel
BuildRequires: pari-devel
BuildRequires: pari-gp
BuildRequires: pcre-devel
BuildRequires: pcre2-devel
BuildRequires: postgresql-devel
BuildRequires: readline-devel
BuildRequires: screen
BuildRequires: vim-data
BuildRequires: pkgconfig(x11)
BuildRequires: pkgconfig(xaw6)
BuildRequires: pkgconfig(xext)
BuildRequires: pkgconfig(xpm)
BuildRequires: pkgconfig(zlib)
#
# If set to yes do not forget to add
# gcc-c++
# to BuildRequires
#
%global ldflags %{nil}
%ifarch %arm ppc ppc64 ppc64le s390 s390x %ix86
%global _lto_cflags %{nil}
%else
%global _lto_cflags %{_lto_cflags} -ffat-lto-objects
%endif
%global rlver %(rpm -q --qf '%%{VERSION}' readline-devel | sed 's/\\.//g')
%define add_optflags(a:f:t:p:w:W:d:g:O:A:C:D:E:H:i:M:n:P:U:u:l:s:X:B:I:L:b:V:m:x:c:S:E:o:v:) \
%global optflags %{optflags} %{**}
%define add_ldflags(a:f:t:p:w:W:d:g:O:A:C:D:E:H:i:M:n:P:U:u:l:s:X:B:I:L:b:V:m:x:c:S:E:o:v:) \
%global ldflags %{ldflags} %{**}
Requires(pre): vim
Requires(pre): vim-data
Requires: ffcall
# CLISP memory image data are compressed with gzip
Requires: /usr/bin/gzip
Provides: %{name}-devel
Suggests: %{name}-doc
%description
Common Lisp is a high-level, all-purpose programming language. CLISP is
an implementation of Common Lisp that closely follows the book "Common
Lisp - The Language" by Guy L. Steele Jr. This package includes an
interactive programming environment with an interpreter, a compiler,
and a debugger. Start this environment with the command 'clisp'.
%package doc
Summary: Documentation of CLisp
Group: Development/Languages/Other
Requires: %{name}
%if 0%{?suse_version} >= 1120
BuildArch: noarch
%endif
%description doc
CLISP documentation is placed in the following directories:
/usr/share/doc/packages/clisp/
/usr/share/doc/packages/clisp/doc/
As well as the conventional CLISP, this package also includes CLX, an
extension of CLISP for the X Window System. The X Window System must be
installed before running the clx command. The description of this CLX
version (new-clx) is placed in
/usr/share/doc/packages/clisp/clx/
with the file README. The subdirectory
/usr/share/doc/packages/clisp/clx/demos/
contains two nice applications.
%prep
%setup -qT -b0 -n %{name}-%{version}+git%{vdate}.%{commit}
%patch -P 1 -p1 -b .sel
%patch -P 2 -p1 -b .wooh
%patch -P 4 -p1 -b .conf
%patch -P 5 -p1 -b .gc
%patch -P 6 -p1 -b .demos
%patch -P 7 -p1 -b .psql
%patch -P 12 -p1 -b .p12
%patch -P 13 -p0 -b .p13
%patch -P 14 -p0 -b .p14
%patch -P 16 -p1 -b .p16
%build
%add_optflags -g3 -D_GNU_SOURCE -D_DEFAULT_SOURCE -D_XOPEN_SOURCE
%add_optflags -fno-strict-aliasing -fPIC -pipe -Wa,--noexecstack
%add_optflags -Wno-unused -Wno-uninitialized -Wno-implicit-fallthrough -Wno-volatile-register-var -Wno-address
%add_optflags -Wno-clobbered -Wno-dangling-pointer -Wno-unused-result -Wno-missing-declarations -Wno-cast-function-type
%{expand:%%global optflags %(echo "%{optflags}"|sed -r -e s/-fstack-protector-strong// -e s/-fstack-clash-protection//)}
%{expand:%%global optflags %%optflags %(getconf LFS_CFLAGS)}
%add_ldflags -Wl,--as-needed -Wl,-z,relro -Wl,-z,noexecstack
#
# Overwrite stack size limit (hopefully a soft limit only)
#
ulimit -Ss unlimited || true
ulimit -Hs unlimited || true
unset LC_CTYPE
LANG=C.UTF-8
LC_ALL=C.UTF-8
export LANG LC_ALL
#
# Current system
#
SYSTEM=${RPM_ARCH}-suse-linux
export PATH="$PATH:."
#
# Set gcc command line but do not use CFLAGS
%if %{with debug}
export CC="g++"
DEBUG=--with-debug
%add_optflags -g3 -DDEBUG_GCSAFETY
%else
DEBUG=
export CC="gcc"
%endif
export MYCFLAGS=""
%ifarch s390x ppc64 ppc64le
%{expand:%%global optflags %(echo "%{optflags}"|sed -r -e s/-fstack-protector-strong// -e s/-fstack-clash-protection//)}
%add_optflags -fno-pie -fno-PIE
%add_ldflags -no-pie
MYCFLAGS=-O
%endif
%ifarch %arm
%{expand:%%global optflags %(echo "%{optflags}"|sed -r -e s/-O[0-9]/-O/g)}
MYCFLAGS=-O
%endif
%ifarch aarch64
%endif
%ifarch ppc
%endif
%ifarch s390
%endif
%ifarch alpha
%endif
%ifarch %ix86
%add_optflags -ffloat-store
MYCFLAGS=-O
%endif
%ifarch x86_64 sparc sparc64 ia64 s390x ppc64 ppc64le
%add_optflags -fno-gcse
%endif
%ifarch ia64 s390x ppc64 ppc64le
%{expand:%%global optflags %(echo "%{optflags}"|sed -r -e s/-O[0-9]/-O/g)}
MYCFLAGS=-O
%endif
%ifarch sparc sparc64
%add_optflags -mcpu=v9
%endif
#
# FastCGI-devel seems a bit broken
#
%add_optflags -I%{_includedir}/fastcgi
# From src/makemake.in
# <cite>
# Do NOT enable -DSAFETY=3 here, because -DSAFETY=3 not only disables some
# optimizations but also enables some debugging features (STACKCHECKs), which
# is not in the scope of --enable-portability.
# </cite>
port=''
%ifarch s390x
##port='--enable-portability'
%endif
#
# Report final architectures
#
echo $(uname -i -m -p) %_build_arch %_arch
echo | $CC %{optflags} -v -E - 2>&1 | grep /cc1
#
# Environment for the case of missing terminal
#
%global _configure screen -D -m setarch $(uname -m) -R ./configure
%global _make screen -D -m setarch $(uname -m) -R make
SCREENDIR=$(mktemp -d ${PWD}/screen.XXXXXX) || exit 1
SCREENRC=${SCREENDIR}/clisp
export SCREENRC SCREENDIR
exec 0< /dev/null
SCREENLOG=${SCREENDIR}/log
cat > $SCREENRC<<-EOF
deflogin off
deflog on
logfile $SCREENLOG
logfile flush 1
logtstamp off
log on
setsid on
scrollback 0
silence on
utf8 on
EOF
find -name configure | xargs -r \
sed -ri "/ac_precious_vars='build_alias\$/ {N; s/build_alias\\n//; }"
# Runtime linker choose system libraries
sed -ri 's/(\$\{wl\})-rpath (\$\{wl\})/\1-rpath-link \2/g' src/build-aux/config.rpath
# Link libraries if really needed
sed -ri "s/CC='\\$\{CC\}'/CC='\\$\{CC\} -Wl,--as-needed'/g" src/makemake.in
#Default browser
sed -ri 's/;; (\(setq \*browser\* .*\))/\1/' src/cfgunix.lisp
#The pari lib doesn ot know anymore about diffptrE
sed -ri 's/(\(def-c-var diffptr)/;; \1/p' modules/pari/pari.lisp
#
# The modules i18n, syscalls, regexp
# are part of the base clisp system.
#
> $SCREENLOG
tail -q -s 0.5 -f $SCREENLOG & pid=$!
%_configure build ${DEBUG} \
${port+"$port"} \
--prefix=%{_prefix} \
--exec-prefix=%{_prefix} \
--libdir=%{_libdir} \
--vimdir=%{vimdir} \
--fsstnd=suse \
--with-readline \
--with-dynamic-modules \
--with-ffcall \
--with-gettext \
--with-module=asdf \
--with-module=dbus \
--with-module=editor \
--with-module=fastcgi \
--with-module=queens \
--with-module=gdbm \
--with-module=gtk2 \
--with-module=pari \
--with-module=pcre \
--with-module=rawsock \
--with-module=zlib \
--with-module=libsvm \
--with-module=bindings/glibc\
--with-module=clx/new-clx \
--with-module=berkeley-db \
--with-module=postgresql \
--config \
CC="${CC}" \
CFLAGS="%{optflags}" \
LDFLAGS="%{ldflags}"
%_make -C build lispbibl.h
grep TYPECODES build/lispbibl.h || :
%_make -C build
%_make -C build check
#
# Stop tail
#
sleep 1
kill $pid
#
# Check for errors
#
check=no
for err in build/tests/*.erg
do
test -e "$err" || break
check=yes
cat $err
done
if test $check != no
then
type -p uname > /dev/null 2>&1 && uname -a || :
type -p netstat > /dev/null 2>&1 && netstat -i || :
type -p netstat > /dev/null 2>&1 && netstat -x || :
type -p ip > /dev/null 2>&1 && ip link || :
type -p ss > /dev/null 2>&1 && ss -x || :
fi
#
%install
#
# Clean
#
find modules/clx/ -name '*.demos' | xargs --no-run-if-empty rm -vf
#
# Current system
#
. ./version.sh
SYSTEM=${RPM_ARCH}-suse-linux
LSPDOC=%{_docdir}/clisp
DOCDOC=${LSPDOC}/doc
CLXDOC=${LSPDOC}/clx
LSPLIB=%{_libdir}/clisp-${VERSION_NUMBER}
CLXLIB=${LSPLIB}/full
#
# Install the current system
#
setarch $(uname -m) -R make -C build install prefix=%{_prefix} \
exec_prefix=%{_prefix} \
mandir=%{_mandir} \
libdir=%{_libdir} \
DESTDIR=%{buildroot} \
INSTALL_DATA="install -cm 0444"
#
# The CLX interface
#
install -d %{buildroot}${CLXDOC}
install -d %{buildroot}${CLXLIB}
pushd modules/clx/new-clx/
install -c -m 0444 README %{buildroot}${CLXDOC}/
install -c -m 0444 %{S:4} %{buildroot}${CLXDOC}/
tar cf - demos/ | (cd %{buildroot}${CLXDOC}/ ; tar xf - )
popd
pushd modules/clx/
tar xfz clx-manual.tar.gz -C %{buildroot}${CLXDOC}
popd
find %{buildroot} -name "*.a" | xargs chmod u+w
chmod u+xrw,a+rx %{buildroot}%{_bindir}/clisp
chmod u+xrw,a+rx %{buildroot}%{_bindir}/clisp-link
chmod -R g+r,o+r %{buildroot}${LSPDOC}/
chmod a-x %{buildroot}${CLXDOC}/clx-manual/html/doc-index.cgi
find %{buildroot}${LSPDOC} -type d | xargs chmod 755
rm -f %{buildroot}${CLXDOC}/*,v
rm -f %{buildroot}${CLXDOC}/.\#*
rm -f %{buildroot}${CLXDOC}/demos/*,v
rm -f %{buildroot}${CLXDOC}/demos/.\#*
rm -f %{buildroot}${CLXDOC}/demos/*.orig
find %{buildroot}${LSPLIB}/ -name '*.dvi' | xargs -r rm -f
find %{buildroot}${LSPLIB}/ -name '*.run' | xargs -r chmod 0755
rm -rf %{buildroot}${LSPLIB}/new-clx/demos/
find %{buildroot} -type f | xargs -r chmod u+w
chmod a+x %{buildroot}${LSPLIB}/build-aux/{config,depcomp}*
install -c -m 644 %{S:2} %{buildroot}%{_datadir}/emacs/site-lisp/clhs.el
%fdupes %{buildroot}${LSPLIB}/
%find_lang clisp
%find_lang clisplow clisp.lang
%files -f clisp.lang
%defattr(-,root,root,755)
%{_bindir}/clisp
%{_bindir}/clisp-link
%{_libdir}/clisp-%{version}*/
%{_datadir}/aclocal/clisp.m4
%{_datadir}/emacs/site-lisp/
%doc %{_datadir}/man/man1/clisp*.1.gz
%{vimdir}/lisp.vim
%files doc
%defattr(-,root,root,755)
%{_docdir}/clisp/
%changelog