X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~mdw/git/clg/blobdiff_plain/ec75b3fc8610f97c7cfffb0e06187a75fd43acfd..HEAD:/tools/config.lisp

diff --git a/tools/config.lisp b/tools/config.lisp
index 5f74d70..4b3341b 100644
--- a/tools/config.lisp
+++ b/tools/config.lisp
@@ -2,50 +2,35 @@ (defpackage #:pkg-config
   (:use #:common-lisp #:clg-utils #+(or cmu clisp) #:ext #+sbcl #:sb-ext)
   #+sbcl
   (:import-from #:sb-int #:featurep)
-  (:export #:pkg-cflags #:pkg-libs #:pkg-exists-p #:pkg-version #:pkg-variable)
-  (:export #:featurep #:sbcl>=))
+  (:export #:pkg-cflags #:pkg-libs #:pkg-exists-p #:pkg-version
+           #:pkg-variable #:pkg-libdir #:tmpname)
+  (:export #:featurep #:sbcl>= #:sbcl< #:clisp>= #:clisp<))
 
 (in-package #:pkg-config)
 
-(defparameter *pkg-config* "/usr/bin/pkg-config")
+(defparameter *pkg-config* "pkg-config")
 
 
-#+(or sbcl cmu)
-(defun run-pkg-config (package error-p &rest options)
-  (let ((process
-	 (run-program
-	  *pkg-config* (cons package options) :wait t :output :stream)))
-    (unless process
-      (error "Unable to run ~A" *pkg-config*))
-    (let ((exit-code (process-exit-code process)))
-      (unless (or (not error-p) (zerop exit-code))
-	(error
-	 (or
-	  (format nil "~A: ~{~A~%~}" *pkg-config* (read-lines (process-error process)))
-	  (format nil "~A terminated with exit code ~A"
-		  *pkg-config* exit-code))))
-      (let ((output (read-lines (process-output process))))	  
-	(process-close process)
-	(values output exit-code)))))
+(defun tmpname (suffix)
+  (format nil "~Aclg-~A-~A"
+   #-win32 "/tmp/" #+win32 "c:/temp/" 
+   #+sbcl(sb-posix:getpid)
+   #+cmu(unix:unix-getpid)
+   #+clisp(os:process-id)   
+   suffix))
 
-#+clisp
 (defun run-pkg-config (package error-p &rest options)
-  (let ((outfile (format nil "/tmp/clg-pkg-config-~A-output" (os:process-id)))
-	(errfile (format nil "/tmp/clg-pkg-config-~A-error" (os:process-id))))
+  (let ((outname (tmpname "pkg-config")))
     (unwind-protect
-	(let ((exit-code 
-	       (run-shell-command 
-		(format nil "~A ~A ~{~A ~}2>~A" 
-		 *pkg-config* package 
-		 (mapcar #'(lambda (option) 
-			     (format nil "'~A'" option))
-			 options)
-		 errfile)
-		:output outfile :if-output-exists :overwrite)))
+	(let* ((asdf::*verbose-out* nil)
+	       (exit-code 
+		(asdf:run-shell-command 
+		 "~A ~A ~:[~;--print-errors ~]~{~A ~} >~A 2>&1"
+		 *pkg-config* package error-p options outname)))
 	  (cond
 	   ((= exit-code 127) (error "Unable to run ~A" *pkg-config*))
 	   ((and error-p (not (zerop exit-code)))
-	    (with-open-file (output errfile)
+	    (with-open-file (output outname)
 	      (let ((errmsg (read-lines output)))
 		(error
 		 (if (not errmsg)
@@ -53,12 +38,10 @@ (defun run-pkg-config (package error-p &rest options)
 		   (format nil "~A: ~{~A~%~}" *pkg-config* errmsg))))))
 	   (t
 	    (values 
-	     (with-open-file (output outfile)
+	     (with-open-file (output outname)
 	       (read-lines output))
 	     exit-code))))
-      (progn
-	(delete-file outfile)
-	(delete-file errfile)))))
+      (delete-file outname))))
 
 
 (defun pkg-cflags (package)
@@ -68,37 +51,80 @@ (defun pkg-libs (package)
   (split-string (first (run-pkg-config package t "--libs"))))
 
 
-(defun pkg-exists-p (package &key version atleast-version max-version
-		     ( error t))
+;; With
+;;   (let ((version-check
+;; 	 (cond
+;; 	  (version (format nil "= ~A" version))
+;; 	  (atleast-version (format nil ">= ~A" atleast-version))
+;; 	  (max-version (format nil "<= ~A" max-version))
+;; 	  (t ""))))
+;;     ...)
+;; when running
+;;   (PKG-EXISTS-P "glib-2.0" :ATLEAST-VERSION "2.4.0" :ERROR T)
+;; the EXIT-CODE in RUN-PKG-CONFIG will be 1 on ms windows and 0 on linux
+
+;; Both on ms windows and linux
+;;   "pkg-config glib-2.0 --print-errors -exists >=2.4.0" is O.K. but
+;;   "pkg-config glib-2.0 --print-errors -exists >= 2.4.0" prints out
+;;     an error message.
+;; However,
+;;   "pkg-config glib-2.0 --print-errors -exists =2.12.11" prints out
+;;     an error message but
+;;   "pkg-config glib-2.0 --print-errors -exists = 2.12.11" is O.K.
+;; We can get around this problem by using
+;;   (let ((version-check
+;; 	 (cond
+;; 	  (version (format nil "--exact-version=~A" version))
+;; 	  (atleast-version (format nil "--atleast-version=~A" atleast-version))
+;; 	  (max-version (format nil "--max-version=~A" max-version))
+;; 	  (t ""))))
+;;     ...)
+;;  - cph 17-May-2007
+
+;; Could the problem with --exists on win32 be caused by improper quoting?
+;; Since --exact-version, --atleast-version and --max-version doesn't print
+;; any error message, we stick to --exists on non Win32 platforms.
+;;  - esj 2007-06-14
+
+
+;; --fix: in win32 sbcl
+;;        (pkg-exists-p "glib-2.0" :version "3.12.11" :error t)
+;;        will hang indefinitely.   - cph 17-May-2007
+
+(defun pkg-exists-p (package &key version atleast-version max-version error)
   (let ((version-check
 	 (cond
-	  (version (format nil "= ~A" version))
-	  (atleast-version (format nil ">= ~A" atleast-version))
-	  (max-version (format nil "<= ~A" max-version))
+	  (version 
+	   #-win32(format nil "--exists \"= ~A\"" version)
+	   #+win32(format nil "--exact-version=~A" version))
+	  (atleast-version 
+	   #-win32(format nil "--exists \">= ~A\"" atleast-version)
+	   #+win32(format nil "--atleast-version=~A" atleast-version))
+	  (max-version 
+	   #-win32(format nil "--exists \"<= ~A\"" max-version)
+	   #+win32(format nil "--max-version=~A" max-version))
 	  (t ""))))
-    (if error
-	(progn
-	  (run-pkg-config package t "--print-errors" "--exists" version-check)
-	  t)
-      (multiple-value-bind (output exit-code)
-	  (run-pkg-config package nil "--exists" version-check)
-	(declare (ignore output))
-	(zerop exit-code)))))
-
+    (zerop (nth-value 1 (run-pkg-config package error version-check)))))
 
 (defun pkg-version (package)
   (first (run-pkg-config package t "--modversion")))
 
-
 (defun pkg-variable (package variable)
   (first (run-pkg-config package t "--variable" variable)))
 
+(defun pkg-libdir (package)
+  #-win32
+  (pkg-variable package "libdir")
+  #+win32
+  (let ((ldir (pkg-variable package "libdir")))
+    (format nil "~Abin" (subseq ldir 0 (search "lib" ldir :from-end t)))))
+  
 
 (defun |#?-reader| (stream subchar arg)
   (declare (ignore subchar arg))
-  (let ((not-p (when (char= (peek-char nil stream) #\-)
-		 (read-char stream)))
-	(conditional (read stream t nil t)))
+  (let* ((not-p (when (char= (peek-char nil stream) #\-)
+		  (read-char stream)))
+	 (conditional (read stream t nil t)))
     (cond
      (*read-suppress* (read stream t nil t))
      ((not *read-eval*)
@@ -118,20 +144,56 @@ (set-dispatch-macro-character #\# #\? #'|#?-reader|)
 #+sbcl
 (progn
   (defun sbcl-version ()
-    (let ((dot1 (position #\. (lisp-implementation-version)))
-	  (dot2 (position #\. (lisp-implementation-version) :from-end t)))
+    (values-list
+     (loop
+      repeat 4
+      ;; We use . and - as delimiters because some Linux
+      ;; distributions tend to patch SBCL and add a distro-specific
+      ;; version tag (like 1.0.19-gentoo).
+      for part in (split-string (lisp-implementation-version) :delimiter '(#\. #\-))
+      while (every #'digit-char-p part)
+      collect (parse-integer part))))
+  (defun sbcl>= (major minor micro &optional patch)
+    (multiple-value-bind (%major %minor %micro %patch) (sbcl-version)      
+      (or 
+       (> %major major)
+       (and (= %major major) (> %minor minor))
+       (and (= %major major) (= %minor minor) (> %micro micro))
+       (and 
+	(= %major major) (= %minor minor) (= %micro micro)
+	(>= (or %patch 0) (or patch 0))))))
+  (defun sbcl< (major minor micro &optional patch)
+    (not (sbcl>= major minor micro patch))))
+
+#-sbcl
+(progn
+  (defun sbcl>= (major minor micro &optional patch)
+    (declare (ignore major minor micro patch))
+    nil)
+  (defun sbcl< (major minor micro &optional patch)
+    (declare (ignore major minor micro patch))
+    nil))
+
+#+clisp
+(progn
+  (defun clisp-version ()
+    (let* ((dot (position #\. (lisp-implementation-version))))
       (values 
-       (parse-integer (lisp-implementation-version) :end dot1)
-       (parse-integer (lisp-implementation-version) :start (1+ dot1) :end dot2)
-       (parse-integer (lisp-implementation-version) :start (1+ dot2)))))
-  (defun sbcl>= (req-major req-minor req-micro)
-    (multiple-value-bind (major minor micro) (sbcl-version)      
+       (parse-integer (lisp-implementation-version) :end dot)
+       (parse-integer (lisp-implementation-version) :start (1+ dot) :junk-allowed t))))
+  (defun clisp>= (req-major req-minor)
+    (multiple-value-bind (major minor) (clisp-version)      
       (or 
        (> major req-major)
-       (and (= major req-major) (> minor req-minor))
-       (and (= major req-major) (= minor req-minor) (>= micro req-micro))))))
+       (and (= major req-major) (> minor req-minor)))))
+  (defun clisp< (req-major req-minor)
+    (not (clisp>= req-major req-minor))))
 
-#-sbcl
-(defun sbcl>= (req-major req-minor req-micro)
-  (declare (ignore req-major req-minor req-micro))
-  nil)
+#-clisp
+(progn
+  (defun clisp>= (req-major req-minor)
+    (declare (ignore req-major req-minor))
+    nil)
+  (defun clisp< (req-major req-minor)
+    (declare (ignore req-major req-minor))
+    nil))