Re: [Axiom-developer] def.lisp

[root]

> 
> | Tim --
> | 
> |   def.lisp is loaded twice into debugsys.
> 
> This patch -- applied to build-improvements -- removes the duplicate
> load.

This patch is incorrect and should be removed.




It turns out that (see lines 152, 154of the build-interpsys function
in util.lisp) there are lists of functions which will trigger
autoloading of files for a specific purpose.

Autoloading works by replacing the function definition you see in
various files with an autoload function (see line 250 in util.lisp).

When you try to execute a function you do NOT get the function 
defined in the source file. Instead you execute the mkBootAutoLoad
function which loads all of the files in the list (using the 
boot-load function). Then it "re-executes" the call.

Thus Axiom changes itself at runtime. You have to be very careful
what macros exist, what the environment is, and what the definitions
of the autoloaded functions are.






There is a list of functions (see line 357 of util.lisp) that will
trigger autoloading of files which include def.lisp. These files
are the functions needed to translate boot code to common lisp.

There is a list of functions (see line 448 of util.lisp) that will
trigger autoloading of files which include def.lisp. These files
are the functions needed to translate aldor code from spad code.
(I vaguely remember working on that function). So this change
would cause a failure only after the aldor compiler is rejoined
to axiom.

As you can see these are two separate uses that occur at two
different times for two different reasons under two different 
conditions.

This is why I say it is much harder to change axiom than it appears.
Be very careful about preserving build order from the makefiles
(because macros change the meaning of things), preserving the files
that get loaded even if the reasons are not obvious, preserving the
symbols that get defined because the compiler dynamically constructs
symbols, etc.






Nothing in Axiom is simple, functions get redefined "on the fly"
(this is also how algebra works), symbols get redefined, results
get cached. It's all highly optimized and extremely self-modifying.
And it all has to be checked in detail before going gold.






It is very easy to break things and very hard to find and debug them.

t