mirror of
https://github.com/kanaka/mal.git
synced 2024-11-11 00:52:44 +03:00
00c3a3c33d
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.
54 lines
1.4 KiB
Ada
54 lines
1.4 KiB
Ada
with Ada.Characters.Latin_1;
|
|
|
|
with Printer;
|
|
|
|
package body Err is
|
|
|
|
use Ada.Strings.Unbounded;
|
|
use Types;
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
procedure Add_Trace_Line (Action : in String;
|
|
Ast : in Types.Mal.T)
|
|
is
|
|
begin
|
|
Append (Trace, " in ");
|
|
Append (Trace, Action);
|
|
Append (Trace, ": ");
|
|
Printer.Pr_Str (Trace, Ast);
|
|
Append (Trace, Ada.Characters.Latin_1.LF);
|
|
end Add_Trace_Line;
|
|
|
|
procedure Check (Condition : in Boolean;
|
|
Message : in String)
|
|
is
|
|
begin
|
|
if not Condition then
|
|
Raise_With (Message);
|
|
end if;
|
|
end Check;
|
|
|
|
procedure Raise_With (Message : in String) is
|
|
begin
|
|
Data := (Kind_String, To_Unbounded_String (Message));
|
|
Set_Unbounded_String (Trace, "Uncaught exception: ");
|
|
Append (Trace, Message);
|
|
Append (Trace, Ada.Characters.Latin_1.LF);
|
|
raise Error;
|
|
end Raise_With;
|
|
|
|
function Throw (Args : in Mal.T_Array) return Mal.T is
|
|
begin
|
|
Check (Args'Length = 1, "expected 1 parameter");
|
|
Data := Args (Args'First);
|
|
Set_Unbounded_String (Trace, "Uncaught exception: ");
|
|
Printer.Pr_Str (Trace, Data);
|
|
Append (Trace, Ada.Characters.Latin_1.LF);
|
|
-- A raise value is equivalent to a raise statement, but
|
|
-- silents a compiler warning.
|
|
return raise Error;
|
|
end Throw;
|
|
|
|
end Err;
|