Clon v1.0b18 is now out. Compared to the previous version, the only small bit of change is the fact that the CLISP implementation now depends only optionally on cffi, whereas that dependency was mandatory before. Doing this is actually quite simple but raised the question of optional ASDF system dependencies, a topic on which there's quite a bit to be said.
A bit of context first. Clon has a terminal autodetection feature which allows it to automatically highlight its output on a tty (see --clon-highlight=auto) and also compute the output line width in case the COLUNMS environment variable is not set. This feature requires an ioctl call which is beyond Lisp. Since one of my goals is to have as few dependencies as possible (zero being the ideal number), I looked at compiler-specific solutions to this problem. The result is that SBCL, CMU-CL, CCL and ECL provide solutions almost out-of-the-box: SBCL has a grovel contributed module, CMU-CL and CCL already have system bindings and ECL has its own ffi interface. The ABCL port doesn't support terminal autodetection yet, but that's another (Java) story. The only black sheep in the picture is CLISP which, as far as I can tell, neither has a native binding for ioctl, nore any built-in grovel facility, hence the need for cffi.
Previously, my system definition file was like that:
#+clisp (asdf:operate 'asdf:load-op :cffi-grovel)
(asdf:defsystem :com.dvlsoft.clon
#| ... |#
:depends-on (#+clisp :cffi)
:components ((:file "package")
#+clisp
(:module "clisp"
:depends-on ("package")
:components ((cffi-grovel:grovel-file "constants")))
(module "src"
:depends-on ("package" #+clisp "clisp")
:components #| ... |#)))
And then later, I had a file with the concerned utility function:
(defun stream-line-width (stream)
#+clisp (#| CLISP implementation |#)
#| etc. |#)
After that, I started looking at ways to make the dependency on cffi optional. After all, it makes sense to avoid that dependency at the cost of not being able to autodetect terminals.
One thing I fell on almost by accident is ASDF's :weakly-depends-on keyword. Here is an interesting thread about it. It was an accident because that feature is not documented :-( People, however, have very mitigated feelings about it, as shown in this other thread (syntax and semantics both appear somewhat shaky and underspecified). Besides, the aparent behavior is that if A weakly depends on B and B is not present, then A is operated anyway. So I could probably have my "src" module weakly depend on the "clisp" one, but that doesn't change the fact the "clisp" module should not be included at all if cffi is not there.
In the same thread, somebody proposes another kind of dependency called :contigent-on which looks closer to what I would need for the "clisp" module: a module the contingency of which is not present will not be processed. This new kind of dependency doesn't seem to be implemented yet, however.
So, all of this seems a bit frightening. Too borderline for my taste. Fortunately, my solution is much simpler, although probably not universal.
This first thing to do is only attempt to load cffi-grovel:
(eval-when (:load-toplevel :execute)
#+clisp (handler-case (asdf:operate 'asdf:load-op :cffi-grovel)
(asdf:missing-component ()
(format *error-output* "~
*********************************************************************
* WARNING: ASDF component CFFI-GROVEL not found.
* Clon will be loaded without support for terminal autodetection.
* See section A.1 of the user manual for more information.
*********************************************************************"))))
After that, if loading it were successful, we end up with cffi as a feature, so we can just conditionalize on that:
(asdf:defsystem :com.dvlsoft.clon
#| ... |#
:depends-on (#+(and clisp cffi) :cffi)
:components ((:file "package")
#+(and clisp cffi)
(:module "clisp"
:depends-on ("package")
:serial t
:components ((cffi-grovel:grovel-file "constants")))
(module "src"
:depends-on ("package" #+(and clisp cffi) "clisp")
:components #| ... |#)))
One last problem remains however: what to do in the source code, for the feature-dependent parts. Conditionalizing an ASDF system may indeed lead to trouble: for instance, what would happen if the function stream-line-width was compiled with cffi around, and later used in a context where it is not? To be on the safe side, what you really need is to dynamically check for the feature. One possible solution is this:
- move all feature-dependent code to the "clisp" module and make that a protocol,
- everytime you need to access the feature, dynamically check whether the protocol functions are
fbound.
In my specific case, what I did was to implement a CLISP-specific version of stream-line-width, called clisp/stream-line-width and put it in a new file in the "clisp" module, now defined as follows:
#+(and clisp cffi)
(:module "clisp"
:depends-on ("package")
:serial t
:components ((cffi-grovel:grovel-file "constants")
(:file "util")))
Then, the original function is rewritten like this:
(defun stream-line-width (stream)
#+clisp (when (fboundp 'clisp/stream-line-width) (clisp/stream-line-width stream))
#| etc. |#)
So now I think I'm on the safe side, and Clon has zero mandatory dependency again...
