( This page is part of the NOVA system. )

Boot

"Boot" stores code to get NOVA up and running.

Files

nova/lisp/config.apps: A convenient place to store global variables.
nova/lisp/make.lisp: The first file to load (it loads everything else).

make.lisp

"make" lists the files to be loaded, in their best load order. Change the following form to load different files in different orders.

 (files  '(  
                tricks/macros
                tricks/eg
                tricks/lib
                guess/guess-db
                config
                guess/guess
                xomo/coc-lib
                xomo/model-defaults
                xomo/effort-model
                xomo/defects-model
                xomo/months-model
                xomo/threats-model
                misc/demos
                ))

"make" also defines functions for showing copyright and contact information. Change the following form to stamp yourself on the system.

(let ((what   "NOVA v0.1")
      (who    "Tim Menzies")
      (email  "tim@menzies.us")
      (when   2008))

  (defun about     () (about-string what when who email))
  (defun copyright () (gpl3-string   what when who email))  
  (defun version   () (format nil "~a. Copyright ~a." what when))
  )

"make" also stores the boot actions to be taken when the system starts up. Change the forms at the bottom of the file to change those start up actions.

; start up actions
(make)
(hello)

Function: maker

The "maker" function is a little utility for simplifying loading code. The code loads either a "lisp" file (the raw source code) or the faster loading "fasl" file (a binary compiled version of the "lisp" file). The optional keys arguments control some compilation options.

If all the control keys are false then the code is loaded the slow way (the raw source code).
If "faslp" is true, then if the compiled version of a file is out of date, then the "lisp" file is re-compiled. Once that is done, the "fasl" file is loaded.
If "forcep" is true, then regardless of the modification.

(defun maker ( &key files 
	       forcep        ; always force a re-compile?
	       (faslp nil)   ; if nil,  just load, don't fasl
	      )
  (labels ; some one-liners for compiling and loading files 
      ((filename (x y)     (string-downcase (format nil "~a.~a"  x y)))
       (src      (f)       (filename f "lisp"))
       (bin      (f)       (filename f "fasl"))   
       (newerp   (f1 f2 )  (> (file-write-date f1)  
			      (file-write-date f2)))
       (compile? (src bin) (or forcep
			       (not (probe-file bin))
			       (newerp src bin)))
       (update   (f)       (if (compile? (src f) (bin f)) 
			       (compile-file (src f))))
       (cake     (f)       (update f) (load (bin f)))
       (loader   (f)       (format t ";;;; FILE: ~a~%" f) (load f))
       (make1    (f)       (if faslp 
			       (cake f) 
			       (loader (src f)))))    
    (mapc #'make1 files)
    ))

In the above, the labels are sub-routines used only by main function "(mapc #'make1 files)". Those functions are:

(filename stem): converts stems like "tricks/eg" to a file name with an extension like "tricks/eg.lisp". By default, "format" returns an upper case symbol- which causes problems on operating systems with case-sensitive file names. Hence, "string-downcase" is called on the output.
(src stem), (bin stem)
: Creates a "lisp" or "fasl" file name.
(newerp file1 file2): Compares the modification date of the "lisp" and the "fasl" file.
(compile? stem): Returns true if a "fasl" file should be regenerated.
update: Ensures the "fasl" file is up to date.
(cake stem): Turns "make" into a compile, then a load of the binary "fasl" file.
(loader file): Loads the files.
(make1 stem): Switches between a "fasl" load or a load of the "lisp" source file.