Bug fix

[clg] / tools / asdf-extensions.lisp

(in-package :asdf)

(export 'load-dso)

(defun concatenate-strings (strings &optional delimiter)
  (if (not (rest strings))
      (first strings)
    (concatenate
     'string
     (first strings)
     (if delimiter (string delimiter) "")
     (concatenate-strings (rest strings) delimiter))))

;;; The following code is more or less copied frm sb-bsd-sockets.asd,
;;; but extended to allow flags set in a general way

(defclass unix-dso (module) ())
(defun unix-name (pathname)
  (namestring 
   (typecase pathname
     (logical-pathname (translate-logical-pathname pathname))
     (t pathname))))

(defmethod input-files ((operation compile-op) (dso unix-dso))
  (mapcar #'component-pathname (module-components dso)))

(defmethod output-files ((operation compile-op) (dso unix-dso))
  (let ((dir (component-pathname dso)))
    (list
     (make-pathname :type "so"
		    :name (car (last (pathname-directory dir)))
		    :directory (butlast (pathname-directory dir))
		    :defaults dir))))


(defmethod perform :after ((operation compile-op) (dso unix-dso))
  (let ((dso-name (unix-name (car (output-files operation dso)))))
    (unless (zerop
	     (run-shell-command
	      "gcc ~A -o ~S ~{~S ~}"
	      (concatenate 'string
;; 			   (sb-ext:posix-getenv "EXTRA_LDFLAGS")
;; 			   " "
			   #+sunos "-shared -lresolv -lsocket -lnsl"
			   #+darwin "-bundle"
			   #-(or darwin sunos) "-shared")
	      dso-name
	      (mapcar #'unix-name
		      (mapcan (lambda (c)
				(output-files operation c))
			      (module-components dso)))))
      (error 'operation-error :operation operation :component dso))))

;; Taken from foreign.lisp in the CMUCL tree, but modified to delay
;; resolving of symbols until they are used
(defun load-dso (file)
  (system::ensure-lisp-table-opened)
  ; rtld global: so it can find all the symbols previously loaded
  ; rtld lazy: that way dlopen will not fail if not all symbols are defined.
  (let ((filename (namestring file)))
    (format t ";;; Loading shared library ~A ...~%" filename)
    (let ((sap (system::dlopen filename (logior system::rtld-lazy system::rtld-global))))
      (cond ((zerop (system:sap-int sap))
	     (let ((err-string (system::dlerror)))

	       ;; For some reason dlerror always seems to return NIL,
	       ;; which isn't very informative.
	       (error "Can't open object ~S: ~S" file err-string)))
	    ((null (assoc sap system::*global-table* :test #'system:sap=))
	     (setf system::*global-table* (acons sap file system::*global-table*))
	     t)
	    (t nil)))))


(defmethod perform ((o load-op) (c unix-dso))
  (let ((co (make-instance 'compile-op)))
    (let ((filename (car (output-files co c))))
      (load-dso filename))))



(defclass c-source-file (source-file) 
  ((cflags :initform nil :initarg :cflags)
   (optimization :initform 2 :initarg :optimization)
   (definitions :initform nil :initarg :definitions)
   (include-paths :initform nil :initarg :include-paths)))


(defmethod output-files ((op compile-op) (c c-source-file))
  (list 
   (make-pathname :type "o" :defaults
		  (component-pathname c))))


(defmethod perform ((op compile-op) (c c-source-file))
  (unless
      (= 0 (run-shell-command "gcc ~A -o ~S -c ~S"
	    (concatenate-strings
	     (append
	      (list "-fPIC")
	      (when (slot-value c 'optimization)
		(list (format nil "-O~A" (slot-value c 'optimization))))
	      (loop 
	       for symbol in (slot-value c 'definitions)
	       collect (format nil "-D~A" symbol))
	      (loop 
	       for path in (slot-value c 'include-paths)
	       collect (format nil "-I~A" path))
	      (slot-value c 'cflags))
	     #\sp)
	    (unix-name (car (output-files op c)))
	    (unix-name (component-pathname c))))
    (error 'operation-error :operation op :component c)))


(defmethod perform ((operation load-op) (c c-source-file))
  t)
  


(defclass library (static-file) 
  ((libdir :initarg :libdir)))


(defun relative-pathname (path)
  (etypecase path
    (cons path)
    (string (if (char= #\/ (char path 0))
		(subseq path 1)
	      path))))

(defmethod component-pathname ((lib library))
  (make-pathname :type "so"
		 :name (component-name lib)
		 :directory (relative-pathname (slot-value lib 'libdir))))

(defmethod perform ((o load-op) (c library))
  (load-dso (component-pathname c)))