@@ -20,7 +20,10 @@ XCVB provides a scalable system to build large software in Lisp, featuring deterministic separate compilation and enforced locally-declared dependencies." :build-depends-on ("/asdf" "/cl-launch" "/asdf-dependency-grovel" - "/closer-mop" "/command-line-arguments" "/xcvb/master") + "/closer-mop" "/command-line-arguments" "/xcvb/master" + (:when (:featurep :sbcl) + (:require :sb-grovel) + (:require :sb-posix))) :depends-on ("conditions" "digest" "normalize-dependency" build.xcvb @@ -27,7 +27,7 @@ enforced locally-declared dependencies. 3 Restrictions on your Lisp Code 3.1 Compile-time side-effects 3.2 Full library needed at compile-time - 3.3 Optimization settings + 3.3 Optimization Settings 4 Combining Multiple Projects 4.1 Module Full Names 4.2 Search Path @@ -51,6 +51,8 @@ enforced locally-declared dependencies. 7.5 ASDF extensions without XCVB equivalent 7.6 Undoing a conversion to XCVB 7.7 Fast non-enforcing builds using POIU + 8 Frequently Asked Questions + 8.1 Why can't module declarations be moved to a central file? About XCVB @@ -1397,3 +1399,40 @@ while getting the flexibility, safety and maintainability that XCVB brings. Finally, note that POIU only supports SBCL and CCL at this time. If you are using another implementation, you should either use ASDF or extend POIU to support your implementation. + + +Frequently Asked Questions +========================== + +Why can't module declarations be moved to a central file? +--------------------------------------------------------- + +The reason why there needs be a module in every file is that +(at least in the current version of XCVB) is that we build using Make, +which uses change detection at the file resolution (using timestamps), +to determine whether or not to recompile object files. + +The failure scenario is what happens when you modify the dependencies +of a Lisp file in a way that changes its semantics +(e.g. a missing macro, special-variable or package declaration, etc., +may cause an error in one case, not the other). +If you want reliable deterministic compilation (the goal of XCVB), +then you want to recompile any time such dependency modification happens. +If you put all the dependencies in a central file, then +whenever the central file is modified because a new file +was added or its dependencies modified, +then everything will have to be recompiled. +Or if you may trust modifications to the central file to not matter, +and experience subtle failures. + +Note that recompiling based on file-contents instead of file timestamp +would have the same issue. The issue is the resolution of change detection. +The solution that would allow to reconcile reliable incremental compilation +with a centralized dependency definition is what in the XCVB TODO file +I called "Exploded File Dependencies": for the sake of detecting changes, +explode the centralized dependency file into one file per Lisp module, +with each per-module exploded bit containing all the dependency information +about that module, and only that information. It's by no means impossible, +but it's just something painful and non-trivial that hasn't shown anywhere +near the top of my TODO list yet. + doc/README.rest @@ -138,10 +138,10 @@ (cond (debug #+sbcl (sb-ext:enable-debugger) - #+clisp (ext:set-global-handler 'serious-condition #'invoke-debugger)) + #+clisp (ext:set-global-handler 'error #'invoke-debugger)) (t #+sbcl (sb-ext:disable-debugger) - #+clisp (ext:set-global-handler 'serious-condition #'bork))) + #+clisp (ext:set-global-handler 'error #'bork))) (values)) ;;; Profiling driver.lisp @@ -2,7 +2,9 @@ (module (:depends-on ("macros" - (:when (:featurep :sbcl) (:require :sb-posix))))) + (:when (:featurep :sbcl) + (:require :sb-grovel) + (:require :sb-posix))))) (in-package :xcvb) farmer.lisp @@ -4,6 +4,7 @@ (module (:depends-on ("specials" "macros" (:when (:featurep :sbcl) + (:require :sb-grovel) (:require :sb-posix))))) (in-package :xcvb) @@ -138,16 +139,29 @@ for this version of XCVB."))) (defun repl-command (args) (unless (null args) (error "repl doesn't take any argument")) - #-(or sbcl clisp) (error "REPL unimplemented") + (initialize-environment) + (xcvb-driver:debugging) + #+clisp (setf *standard-input* *terminal-io*) (throw :repl nil)) (defun repl () - (initialize-environment) - #+sbcl (progn (sb-ext:enable-debugger) (sb-impl::toplevel-repl nil)) - #+clisp (progn (ext:set-global-handler t 'invoke-debugger) - (system::main-loop)) - #-(or sbcl clisp) (error "REPL unimplemented")) - + (let (/ // /// * ** *** + ++ +++ -) + #+sbcl (sb-impl::toplevel-repl nil) + #-sbcl (loop (rep)))) +(defun prompt () + (format nil "~A> " (package-name *package*))) +(defun rep () + (let ((eof '#:eof)) + (format t "~&") + (write-string (prompt)) + (xcvb-driver:finish-outputs) + (setf - (read nil nil eof)) + (when (eq - eof) (exit 0)) + (psetf / (multiple-value-list (eval -)) // / /// //) + (psetf * (car /) ** * *** **) + (psetf + - ++ + +++ ++) + (format t "~{~S~^ ;~%~}" /) + (xcvb-driver:finish-outputs))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Remove XCVB ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -192,7 +206,8 @@ for this version of XCVB."))) (interpret-command-line (command-line-arguments:get-command-line-arguments)) 0)))) - (repl)) + (quit (catch :exit + (repl)))) (defun initialize-environment () #+sbcl (sb-posix:putenv (strcat "SBCL_HOME=" *lisp-implementation-directory*)) main.lisp @@ -1,2 +1,2 @@ #+xcvb (module (:depends-on ("pkgdcl"))) -(cl:defparameter xcvb:*xcvb-version* "0.414") +(cl:defparameter xcvb:*xcvb-version* "0.415") version.lisp 084c24dbb6080d7f2cb9609e1b94206144f7bffd Francois-Rene Rideau fare@tunes.org http://github.com/fare/xcvb/commit/086f40319ee436244a85788b7b2e73ac234ccdb1 086f40319ee436244a85788b7b2e73ac234ccdb1

2009-10-25T13:58:48-07:00

XCVB .415: make the REPL work with CCL and CLISP. Succesful test with CLISP! e30c162e561c454fc89cfc2b9e8ac0a6c83d0a07 Francois-Rene Rideau fare@tunes.org