Implement macros as a bit in the function record as advised in the
process. No need to reinvent Apply anymore.
Also add an explicit Unreferenced pragma to silent a new compiler
warning.
Makefile:
Drop OPT and -gnat2020, not used anymore.
Simplify file list now that each unit has a body.
README:
Remove obsolete items.
Global:
Restrict most pointers to a provable non-null value.
Types: merge intermediate Types.Mal into the Types package. (the
intermediate package was created in order to prevent a circular
dependency, but is not needed anymore).
Most of the noise in the diff is caused by this change.
This allows to remove most Elaboration pragmas.
Declare most types abstract in the visible part,
enforcing the use of the constructor outside the declaring package.
Envs:
Replace the Get recursion with a more efficient loop.
Use MAL objects as key, string pointers do not change speed.
This delegates some checks from the step files.
Split the constructor and Set_Binds, so that an existing environment
can be reused during TCO.
Err:
Attempt to group the calls.
Avoid computing the message when the assertion holds.
Fns:
Declare and use the eval callback only here.
Separate function and macro interfaces.
Keep a reference to the provided parameter list instead of copying them.
Garbage_Collected:
Make explicit that Keep is not inherited.
Printer:
Remove obsolete inline indications and redundant Print_Function helper.
Maps:
Provide a cleaner interface copied from standard library.
Sequences: stop encapsulating the implementation because of the
performance hit.
Steps:
Move map and vector evaluations into separate functions for readability.
Replace return blocks with normal blocks (MAL values are not finalized
anymore).
Rename standard arrays instead of sequence_ptr when possible.
Remove some duplication and indentation from the apply phase.
Move the frequent special forms in front of the test cascade.
When an environment has been created in the same Eval, reuse it.
Strings:
Use the same garbage-collected storage model for all strings.
This seems faster than the default (mutable) string types.
Hide most of the implementation to avoid leaks.
Symbols: stop ensuring unique allocation of symbols. The reduced
garbage collection and comparison time was compensed by the
maintainance of a global hash.
Cyclic references were never deallocated by reference conuting.
Symbols cannot create cyclic structures and are less frequent (one
allocation per symbol), keep reference counting for them.
This slightly improves performances even though many previous
optimizations are removed (environment stack, reuse of memory).
Step caching hash of symbols. This does not seem to improve
performances. Hashing them instead of ordering them does.
Define Repl in the step file instead of globally. Move the eval
built-in function from core into the step file.
When possible, pass Ada records instead of explicit pointers.
In the reader, construct more objects directly as described in the MAL
process, reserve the buffer for sequences and maps
In eval, iterate on vectors without delegation. The increased
complexity was not improving performances. Keep demonstrating Ada
type-safe genericity for maps, where iterating outside Types.Maps
would be less easy and/or efficient.
In quasiquote_list, concatenate in one buffer instead of allocating a
list for each element. The buffer may be reallocated behind the
curtain, but not once per element anymore.
In environments, illustrate tail call optimization when recursion is
more readable than a loop.
Two changes require approval.
* The 'do' special becomes a built-in function similar to first. This
small change reduces the complexity of eval. The last evaluation
cannot benefit from TCO, but the performance change seems invisible.
* read/eval/print acts on each item found in the input string, as if
they were enclosed with (do ..). The guide does not specify what
should happen to text following the first AST, and this change actually
simplifies some things (like dealing with zero AST).
The read-string built-in function only returns the first AST,
as changing this would be much more intrusive.
Other changes seem straightforward.
Global:
* Ada 2020 target assignments (like +=, but more general).
* Use Constant_Indexing aspect for sequences, so that they can be
indexed in source code like native arrays.
* consistency renamings.
'fn' does not include built-in functions, 'function' does.
'list' does not include vectors, 'sequence' does.
Move error handling to a separate package.
* This simplifies code everywhere else.
* Uncaught expressions now report a stack trace.
Types:
* Count allocations and deallocations, check that counts match.
* Share more code between functions and macros.
Core:
* Replace the Core.Ns function returning an array with a procedure
(The intermediate object was preventing the reference counting code
from deallocating some unused objects).
* Implement Prn with Pr_Str.
Printer:
* Change the profile so that the caller spares some allocations.
Reader:
* Share a single buffer of mal values between all recursions.
This significantly reduces the stack footprint.
Steps:
* Fix implementation name (ada.2) in the startup script.
* Let environment variables trigger debugging information.
