Custom Query (1030 matches)

In order to dump an image that I can start, it appears that I need to unload the shared libraries that have been loaded and load them at image startup time. I figured that CLOSE-SHARED-LIBRARY is meant to be used to close and unload a shared library. This function is unavailable on FreeBSD, and it appears that fixing this is not totally trivial, as OPEN-SHARED-LIBRARY seems not to return or store the pointer returned by dlopen. I guess this is not news. Is there a workaround available that makes it possible to use images dumped from a CCL that has shared libraries loaded?

With normal compilation setting, CCL does not detect that the argument list supplied when invoking a function is invalid.

Under certain circumstances that I have not yet isolated, CCL creates the error message "Function call arguments don't match current definition of <function>" when it finds invalid arguments. This is better, but still very unspecific, and makes locating errors harder than one would wish for.

As in:

foo.lisp:
(defun foo (&key a) (declare (ignore a)))
(defun bar () (foo :b 2)) 

Compiled with CCL:

paracetamol 25_> ccl -n -e '(compile-file "/tmp/foo.lisp")' -e '(quit)'
paracetamol 26_> 

SBCL generates useful output:

paracetamol 26_> sbcl --no-userinit --eval '(compile-file "/tmp/foo.lisp")'  --e
val '(quit)'
This is SBCL 1.0.11, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.

; compiling file "/tmp/foo.lisp" (written 12 MAR 2008 11:50:55 AM):
; compiling (DEFUN FOO ...)
; compiling (DEFUN BAR ...)
; file: /tmp/foo.lisp
; in: DEFUN BAR
;     (FOO :B 2)
; 
; caught STYLE-WARNING:
;   :B is not a known argument keyword.
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition


; /tmp/foo.fasl written
; compilation finished in 0:00:00

as does cmucl (no suprise, but still)

netzhansa 5_> lisp -eval '(compile-file "/tmp/foo.lisp")' -eval '(quit)'

; Python version 1.1, VM version Intel x86 on 12 MAR 08 01:01:34 pm.
; Compiling: /tmp/foo.lisp 12 MAR 08 01:01:00 pm

; Converted FOO.
; Compiling DEFUN FOO: 

; 
; 
; File: /tmp/foo.lisp

; In: DEFUN BAR

;   (FOO :B 2)
; Warning: :B is not a known argument keyword.
; 
; Converted BAR.
; Compiling DEFUN BAR: 
; Byte Compiling Top-Level Form: 

; Compilation unit finished.
;   1 warning


; /tmp/foo.x86f written.
; Compilation finished in 0:00:01.
netzhansa 6_> 

As does CLISP:

paracetamol 29_> clisp -x '(compile-file "/tmp/foo.lisp")'
  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8

Welcome to GNU CLISP 2.44 (2008-02-02) <http://clisp.cons.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2008

Type :h and hit Enter for context help.

;; Compiling file /tmp/foo.lisp ...
WARNING in BAR in line 2 :
keyword :B is not allowed for function FOO.
The only allowed keyword is :A.
[FOO was defined in line 1]
;; Wrote file /tmp/foo.fas
0 errors, 1 warning
#P"/tmp/foo.fas" ;
1 ;
1
Bye.
paracetamol 30_> 

To load the system call interfaces, one currently has to copy this piece of code:

(eval-when (:compile-toplevel :execute)
  #+linuxppc-target
  (require "PPC-LINUX-SYSCALLS")
  #+linuxx8664-target
  (require "X8664-LINUX-SYSCALLS")
  #+darwinppc-target
  (require "DARWINPPC-SYSCALLS")
  #+darwinx8664-target
  (require "DARWINX8664-SYSCALLS")
  #+freebsdx8664-target
  (require "X8664-FREEBSD-SYSCALLS")
  )

This is rather inconvenient for the user, as every new architecture and every new operating system requires manual patching of the application that uses the system calls. The upcoming 32 bit X86 port will make this particularily apparent.

I would suggest that CCL provided a single "SYSCALLS" module that selectes the right module to load, so that the application can use

(require "SYSCALLS")

If the eval-when could go, it'd be even better.

I am aware that the system call interfaces vary between architectures and operating systems and that one cannot expect (require "SYSCALLS") to provide for one common interface to the system. Given that most operating systems supported will be Unix based, there is significant overlap between the variants and thus it _will_ be possible to just use code cross-platform in many cases.