hyung-hwan/hak
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
5e402824169fe841702f19575aace10e97567207
hak/h2/lib/h2-scheme.ads
hyung-hwan f875ede81c reorganized h2
2021-08-21 14:31:39 +00:00

659 lines
26 KiB
Ada
Raw Blame History

---------------------------------------------------------------------
-- ##### # # #####
-- # # #### # # ###### # # ###### # # # #
-- # # # # # # ## ## # # # #
-- ##### # ###### ##### # ## # ##### ##### ####### #####
-- # # # # # # # # # # #
-- # # # # # # # # # # # # #
-- ##### #### # # ###### # # ###### # # #######
--
-- Literal
-- Number: 1, 10
-- String: "hello"
--
-- Environment
-- The environment holds the key/value pairs.
--
-- Procedure
-- Some builtin-procedure objects are registered to the top-level environment
-- upon start-up. You can break the mapping between a name and a procedure
-- as it's in the normal environment.
--
-- Syntax Object
-- Some syntax objects are registered upon start-up. They are handled
-- very specially when the list containing one of them as the first argument
-- is evaluated.
--
-- Evaluation Rule
-- A literal object evaluates to itself. A Symbol object evaluates to
-- a value found in the environment. List evaluation is slightly more
-- complex. Each element of a list is evluated using the standard evaluation
-- rule. The first argument acts as a function and the rest of the arguments
-- are applied to the function. An element must evaluate to a closure to be
-- a function. The syntax object bypasses the normal evaluation rule and is
-- evaluated according to the object-specific rule.
--
---------------------------------------------------------------------
with Ada.Unchecked_Conversion;
with H2.Ascii;
generic
type Character_Type is (<>);
package H2.Scheme is
-----------------------------------------------------------------------------
-- EXCEPTIONS
-----------------------------------------------------------------------------
Allocation_Error: exception;
Size_Error: exception;
Syntax_Error: exception;
Evaluation_Error: exception;
Internal_Error: exception;
IO_Error: exception;
Divide_By_Zero_Error: exception;
Numeric_String_Error: exception;
type Interpreter_Record is limited private;
type Interpreter_Pointer is access all Interpreter_Record;
-- -----------------------------------------------------------------------------
-- While I could define Heap_Element and Heap_Size to be
-- the subtype of Object_Byte and Object_Size each, they are not
-- logically the same thing.
-- subtype Heap_Element is Object_Byte;
-- subtype Heap_Size is Object_Size;
--type Heap_Element is mod 2 ** System_Byte_Bits;
--type Heap_Size is range 0 .. (2 ** (System_Word_Bits - 1)) - 1;
subtype Heap_Element is System_Byte;
subtype Heap_Size is System_Size;
-- -----------------------------------------------------------------------
-- An object pointer takes up as many bytes as a system word.
Object_Pointer_Bits: constant := System_Word_Bits;
Object_Pointer_Bytes: constant := Object_Pointer_Bits / System_Byte_Bits;
-- I use the lower 2 bits to indicate the type of an object pointer.
-- A real object pointer is typically allocated on a word boundary.
-- As a result, the lower 2 bits should always be 0. Using this
-- property, I keep some other values at the lower 2 bits to indicate
-- some other direct values like an integer or a character.
Object_Pointer_Type_Bits: constant := 2;
type Object_Pointer_Type is mod 2 ** Object_Pointer_Type_Bits;
Object_Pointer_Type_Pointer: constant Object_Pointer_Type := 2#00#;
Object_Pointer_Type_Integer: constant Object_Pointer_Type := 2#01#;
Object_Pointer_Type_Character: constant Object_Pointer_Type := 2#10#;
Object_Pointer_Type_Byte: constant Object_Pointer_Type := 2#11#;
Object_Pointer_Type_Mask: constant Object_Pointer_Type := 2#11#;
type Object_Record;
type Object_Pointer is access all Object_Record;
for Object_Pointer'Size use Object_Pointer_Bits;
type Object_Bit is mod 2 ** 1;
--for Object_Bit'Size use 1;
-- Object_Word is a numeric type as large as Object_Poinetr;
type Object_Word is mod 2 ** Object_Pointer_Bits;
for Object_Word'Size use Object_Pointer_Bits;
type Object_Half_Word is mod 2 ** (Object_Pointer_Bits / 2);
for Object_Half_Word'Size use (Object_Pointer_Bits / 2);
-- Object_Signed_Word is the signed version of Object_Word.
-- Note Object_Word is a modular type while this is a signed range.
type Object_Signed_Word is range -(2 ** (Object_Pointer_Bits - 1)) ..
+(2 ** (Object_Pointer_Bits - 1)) - 1;
for Object_Signed_Word'Size use Object_Pointer_Bits;
-- The actual number of bits for an integer the number of bits excluding
-- the pointer type bits.
Object_Integer_Bits: constant := Object_Pointer_Bits - Object_Pointer_Type_Bits;
-- Object_Integer represents the range of SmallInteger.
-- It defines an integer that can be held in the upper Object_Integer_Bits
-- bits. Conversion functions betwen Object_Integer and Object_Pointer
-- use the highest 1 bit to represent the sign after shifting. So, the
-- range is shrunk further by 1 bit, resulting in -2 in the foluma below.
-- -----------------------------------------------------------------------
-- type Object_Integer is range -(2 ** (Object_Integer_Bits - 2)) ..
-- +(2 ** (Object_Integer_Bits - 2)) - 1;
-- -----------------------------------------------------------------------
-- If i don't include -(2 ** (Object_Integer_Bits - 1)) into the range,
-- it can be extended to a larger range. That's because the excluded number
-- conflicts with the highest sign bit during the conversion process.
-- -----------------------------------------------------------------------
type Object_Integer is range -(2 ** (Object_Integer_Bits - 1)) + 1 ..
+(2 ** (Object_Integer_Bits - 1)) - 1;
-- -----------------------------------------------------------------------
-- What is a better choice? TODO: decide what to use
-- -----------------------------------------------------------------------
-- Let Object_Integer take up as large a space as Object_Pointer
-- despite the actual range of Object_Integer.
for Object_Integer'Size use Object_Pointer_Bits;
-- The Object_Size type defines the size of object payload.
-- It is the number of payload items for each object kind.
type Object_Size is new System_Size;
for Object_Size'Size use Object_Pointer_Bits; -- for GC
subtype Object_Index is Object_Size range Object_Size(System_Index'First) .. Object_Size(System_Index'Last);
--type Object_Byte is mod 2 ** System_Byte_Bits;
--for Object_Byte'Size use System_Byte_Bits;
subtype Object_Byte is System_Byte;
subtype Object_Character is Character_Type;
type Object_Pointer_Array is array(Object_Index range <>) of Object_Pointer;
type Object_Character_Array is array(Object_Index range <>) of Object_Character;
type Object_Byte_Array is array(Object_Index range <>) of Object_Byte;
type Object_Word_Array is array(Object_Index range <>) of Object_Word;
type Object_Half_Word_Array is array(Object_Index range <>) of Object_Half_Word;
type Object_Character_Array_Pointer is access all Object_Character_Array;
for Object_Character_Array_Pointer'Size use Object_Pointer_Bits;
type Constant_Object_Character_Array_Pointer is access constant Object_Character_Array;
for Constant_Object_Character_Array_Pointer'Size use Object_Pointer_Bits;
subtype Thin_Object_Character_Array is Object_Character_Array(Object_Index'Range);
type Thin_Object_Character_Array_Pointer is access all Thin_Object_Character_Array;
for Thin_Object_Character_Array_Pointer'Size use Object_Pointer_Bits;
type Object_Kind is (
Moved_Object, -- internal use only
Pointer_Object,
Character_Object,
Byte_Object,
Word_Object,
Half_Word_Object
);
for Object_Kind use (
Moved_Object => 0,
Pointer_Object => 1,
Character_Object => 2,
Byte_Object => 3,
Word_Object => 4,
Half_Word_Object => 5
);
-- -----------------------------------------------------------------------
-- Object_Record contains the Flags field that can be used
-- freely for management purpose. The Object_Flags type
-- represents the value that can be stored in this field.
type Object_Flags is mod 2 ** 4;
Syntax_Object: constant Object_Flags := Object_Flags'(2#0001#);
Syntax_Checked: constant Object_Flags := Object_Flags'(2#0010#);
Argument_Checked: constant Object_Flags := Object_Flags'(2#0100#);
type Object_Tag is (
Unknown_Object,
Cons_Object,
String_Object,
Symbol_Object,
Array_Object,
Bigint_Object,
Procedure_Object,
Closure_Object,
Continuation_Object,
Frame_Object
);
type Syntax_Code is (
And_Syntax,
Begin_Syntax,
Case_Syntax,
Cond_Syntax,
Define_Syntax,
Do_Syntax,
If_Syntax,
Lambda_Syntax,
Let_Syntax,
Letast_Syntax,
Letrec_Syntax,
Or_Syntax,
Quasiquote_Syntax,
Quote_Syntax,
Set_Syntax
);
type Object_Sign is (
Positive_Sign,
Negative_Sign
);
type Object_Record(Kind: Object_Kind; Size: Object_Size) is record
Flags: Object_Flags := 0;
Tag: Object_Tag := Unknown_Object;
Scode: Syntax_Code := Syntax_Code'Val(0); -- Used if Flags contain Syntax_Object
Sign: Object_Sign := Positive_Sign; -- Used for Bigint_Object
-- Object payload:
-- I assume that the smallest payload is able to hold an
-- object pointer by specifying the alignement attribute
-- to Object_Pointer_Bytes and checking the minimum allocation
-- size in Allocate_Bytes_In_Heap().
case Kind is
when Moved_Object =>
New_Pointer: Object_Pointer := null;
when Pointer_Object =>
Pointer_Slot: Object_Pointer_Array(1 .. Size) := (others => null);
when Character_Object =>
Character_Slot: Object_Character_Array(1 .. Size) := (others => Object_Character'First);
-- The character terminator is to ease integration with
-- other languages using a terminating null.
-- TODO: can this guarantee terminating NULL? is this
-- terminator guaranteed to be placed after the
-- character_slot without any gaps in between
-- under the current alignement condition?
Character_Terminator: Object_Character := Object_Character'First;
when Byte_Object =>
Byte_Slot: Object_Byte_Array(1 .. Size) := (others => 0);
when Word_Object =>
Word_Slot: Object_Word_Array(1 .. Size) := (others => 0);
when Half_Word_Object =>
Half_Word_Slot: Object_Half_Word_Array(1 .. Size) := (others => 0);
end case;
end record;
for Object_Record use record
Kind at 0 range 0 .. 2; -- 3 bits (0 .. 7)
Flags at 0 range 3 .. 6; -- 4 bits
Tag at 0 range 7 .. 10; -- 4 bits (0 .. 15)
Scode at 0 range 11 .. 14; -- 4 bits (0 .. 15)
Sign at 0 range 15 .. 15; -- 1 bit (0 or 1)
-- there are still some space unused in the first word. What can i do?
end record;
for Object_Record'Alignment use Object_Pointer_Bytes;
-- the following 3 size types are defined for limiting the object size range.
subtype Empty_Object_Record is Object_Record(Byte_Object, 0);
Object_Header_Bits: constant Object_Size := Empty_Object_Record'Size;
-- the number of bytes in an object header. this is fixed in size
-- Object_Header_Bytes: constant Object_Size := Empty_Object_Record'Max_Size_In_Storage_Elements;
Object_Header_Bytes: constant Object_Size := Object_Header_Bits / System_Byte_Bits;
-- the largest number of bytes that an object can hold after the header
Object_Payload_Max_Bytes: constant Object_Size := Object_Size'Last - Object_Header_Bytes;
-- the following types are defined to set the byte range of the object data.
-- the upper bound is set to the maximum that don't cause overflow in calcuating the size in bits.
-- the compiler doesn't seem to be able to return 'Size or 'Max_Size_In_Storage_Elements properly
-- when the number of bits calculated overflows.
Byte_Object_Size_Last: constant Object_Size := Object_Payload_Max_Bytes / (Object_Byte'Size / System_Byte_Bits);
Character_Object_Size_Last: constant Object_Size := Object_Payload_Max_Bytes / (Object_Character'Size / System_Byte_Bits);
Pointer_Object_Size_Last: constant Object_Size := Object_Payload_Max_Bytes / (Object_Pointer'Size / System_Byte_Bits);
Word_Object_Size_Last: constant Object_Size := Object_Payload_Max_Bytes / (Object_Word'Size / System_Byte_Bits);
Half_Word_Object_Size_Last: constant Object_Size := Object_Payload_Max_Bytes / (Object_Half_Word'Size / System_Byte_Bits);
subtype Byte_Object_Size is Object_Size range Object_Size'First .. Byte_Object_Size_Last;
subtype Character_Object_Size is Object_Size range Object_Size'First .. Character_Object_Size_Last;
subtype Pointer_Object_Size is Object_Size range Object_Size'First .. Pointer_Object_Size_Last;
subtype Word_Object_Size is Object_Size range Object_Size'First .. Word_Object_Size_Last;
subtype Half_Word_Object_Size is Object_Size range Object_Size'First .. Half_Word_Object_Size_Last;
-- -----------------------------------------------------------------------------
-- Various pointer classification and conversion procedures
-- -----------------------------------------------------------------------------
function Is_Pointer (Pointer: in Object_Pointer) return Standard.Boolean;
function Is_Special_Pointer (Pointer: in Object_Pointer) return Standard.Boolean;
function Is_Normal_Pointer (Pointer: in Object_Pointer) return Standard.Boolean;
function Is_Integer (Pointer: in Object_Pointer) return Standard.Boolean;
function Is_Character (Pointer: in Object_Pointer) return Standard.Boolean;
function Is_Byte (Pointer: in Object_Pointer) return Standard.Boolean;
function Integer_To_Pointer (Value: in Object_Integer) return Object_Pointer;
function Character_To_Pointer (Value: in Object_Character) return Object_Pointer;
function Byte_To_Pointer (Value: in Object_Byte) return Object_Pointer;
function Pointer_To_Integer (Pointer: in Object_Pointer) return Object_Integer;
function Pointer_To_Character (Pointer: in Object_Pointer) return Object_Character;
function Pointer_To_Byte (Pointer: in Object_Pointer) return Object_Byte;
pragma Inline (Is_Special_Pointer);
pragma Inline (Is_Pointer);
pragma Inline (Is_Integer);
pragma Inline (Is_Character);
pragma Inline (Integer_To_Pointer);
pragma Inline (Character_To_Pointer);
pragma Inline (Byte_To_Pointer);
-- this caused GNAT 4.6.3 to end up with an internal bug when used in the generirc Plain_Integer_Op function.
-- let me comment it out temporarily.
--pragma Inline (Pointer_To_Integer);
pragma Inline (Pointer_To_Character);
pragma Inline (Pointer_To_Byte);
-- -----------------------------------------------------------------------------
function Is_Cons (Source: in Object_Pointer) return Standard.Boolean;
function Is_Bigint (Source: in Object_Pointer) return Standard.Boolean;
pragma Inline (Is_Cons);
pragma Inline (Is_Bigint);
-- -----------------------------------------------------------------------------
type Stream_Record is abstract tagged limited null record;
procedure Open (Stream: in out Stream_Record) is abstract;
procedure Close (Stream: in out Stream_Record) is abstract;
procedure Read (Stream: in out Stream_Record;
Data: out Object_Character_Array;
Last: out Object_Size) is abstract;
procedure Write (Stream: in out Stream_Record;
Data: out Object_Character_Array;
Last: out Object_Size) is abstract;
type Stream_Pointer is access all Stream_Record'Class;
type Stream_Allocator is access
procedure (Interp: in out Interpreter_Record;
Name: access Object_Character_Array;
Result: out Stream_Pointer);
type Stream_Deallocator is access
procedure (Interp: in out Interpreter_Record;
Source: in out Stream_Pointer);
type IO_Flags is mod 2 ** 4;
IO_End_Reached: constant IO_Flags := IO_Flags'(2#0001#);
IO_Error_Occurred: constant IO_Flags := IO_Flags'(2#0001#);
type IO_Record;
type IO_Pointer is access all IO_Record;
type Character_Kind is (End_Character, Normal_Character, Error_Character);
type IO_Character_Record is record
Kind: Character_Kind := End_Character;
Value: Object_Character := Object_Character'First;
end record;
--pragma Pack (IO_Character_Record);
type IO_Record is record
--type IO_Record is limited record
Stream: Stream_Pointer := null;
--Data: Object_Character_Array(1..2048) := (others => Object_Character'First);
Data: Object_Character_Array(1..5) := (others => Object_Character'First);
Last: Object_Size := 0;
Pos: Object_Size := 0;
Flags: IO_Flags := 0; -- EOF, ERROR
Next: IO_Pointer := null;
Iochar: IO_Character_Record; -- the last character read.
end record;
-- -----------------------------------------------------------------------------
type Trait_Mask is mod 2 ** System_Word_Bits;
No_Garbage_Collection: constant Trait_Mask := 2#0000_0000_0000_0001#;
No_Optimization: constant Trait_Mask := 2#0000_0000_0000_0010#;
type Option_Kind is (Trait_Option, Stream_Option);
type Option_Record (Kind: Option_Kind) is record
case Kind is
when Trait_Option =>
Trait_Bits: Trait_Mask := 0;
when Stream_Option =>
Allocate: Stream_Allocator := null;
Deallocate: Stream_Deallocator := null;
end case;
end record;
-- -----------------------------------------------------------------------------
-- The nil/true/false object are represented by special pointer values.
-- The special values are defined under the assumption that actual objects
-- are never allocated on one of these addresses. Addresses of 4, 8, 12 are
-- very low, making the assumption pretty safe. I don't use 0 for Nil_Word
-- as it may conflict with ada's null.
Nil_Word: constant Object_Word := 2#0100#; -- 4
--Nil_Pointer: constant Object_Pointer;
--for Nil_Pointer'Address use Nil_Word'Address;
--pragma Import (Ada, Nil_Pointer);
True_Word: constant Object_Word := 2#1000#; -- 8
--True_Pointer: constant Object_Pointer;
--for True_Pointer'Address use True_Word'Address;
--pragma Import (Ada, True_Pointer);
False_Word: constant Object_Word := 2#1100#; -- 12
--False_Pointer: constant Object_Pointer;
--for False_Pointer'Address use False_Word'Address;
--pragma Import (Ada, False_Pointer);
function Object_Word_To_Pointer is new Ada.Unchecked_Conversion (Object_Word, Object_Pointer);
function Object_Pointer_To_Word is new Ada.Unchecked_Conversion (Object_Pointer, Object_Word);
Nil_Pointer: constant Object_Pointer := Object_Word_To_Pointer(Nil_Word);
True_Pointer: constant Object_Pointer := Object_Word_To_Pointer(True_Word);
False_Pointer: constant Object_Pointer := Object_Word_To_Pointer(False_Word);
-- -----------------------------------------------------------------------------
procedure Open (Interp: in out Interpreter_Record;
Initial_Heap_Size:in Heap_Size;
Storage_Pool: in Storage_Pool_Pointer := null);
procedure Close (Interp: in out Interpreter_Record);
function Get_Storage_Pool (Interp: in Interpreter_Record) return Storage_Pool_Pointer;
procedure Set_Option (Interp: in out Interpreter_Record;
Option: in Option_Record);
procedure Get_Option (Interp: in out Interpreter_Record;
Option: in out Option_Record);
procedure Set_Input_Stream (Interp: in out Interpreter_Record;
Stream: in out Stream_Record'Class);
-- Source must be open for Read() to work.
--procedure Read (Interp: in out Interpreter_Record;
-- Result: out Object_Pointer);
procedure Evaluate (Interp: in out Interpreter_Record;
Source: in Object_Pointer;
Result: out Object_Pointer);
procedure Print (Interp: in out Interpreter_Record;
Source: in Object_Pointer);
procedure Run_Loop (Interp: in out Interpreter_Record;
Result: out Object_Pointer);
procedure Collect_Garbage (Interp: in out Interpreter_Record);
procedure Push_Top (Interp: in out Interpreter_Record;
Source: access Object_Pointer);
procedure Pop_Tops (Interp: in out Interpreter_Record;
Count: in Object_Size);
function Make_String (Interp: access Interpreter_Record;
Source: in Object_Character_Array;
Invert: in Standard.Boolean := Standard.False) return Object_Pointer;
function Make_Symbol (Interp: access Interpreter_Record;
Source: in Object_Character_Array;
Invert: in Standard.Boolean := Standard.False) return Object_Pointer;
function Make_Bigint (Interp: access Interpreter_Record;
Size: in Half_Word_Object_Size) return Object_Pointer;
function Make_Bigint (Interp: access Interpreter_Record;
Value: in Object_Integer) return Object_Pointer;
-- -----------------------------------------------------------------------------
private
package Ch is new H2.Ascii(Object_Character, Object_Character);
package Ch_Code renames Ch.Code;
package Ch_Val renames Ch.Slim; -- Ch.Slim and Ch.Wide are the same as both are Object_Charater above.
type Heap_Element_Array is array(Heap_Size range <>) of aliased Heap_Element;
type Heap_Record(Size: Heap_Size) is record
Space: Heap_Element_Array(1..Size) := (others => 0);
Bound: Heap_Size := 0;
end record;
for Heap_Record'Alignment use Object_Pointer_Bytes;
type Heap_Pointer is access all Heap_Record;
type Heap_Number is mod 2 ** 1;
type Heap_Pointer_Array is array(Heap_Number'First .. Heap_Number'Last) of Heap_Pointer;
type Buffer_Record is record
Ptr: Thin_Object_Character_Array_Pointer := null;
Len: Object_Size := 0;
Last: Object_Size := 0;
end record;
type Token_Kind is (End_Token,
Identifier_Token,
Left_Parenthesis_Token,
Right_Parenthesis_Token,
Period_Token,
Single_Quote_Token,
True_Token,
False_Token,
Character_Token,
String_Token,
Integer_Token
);
type Token_Record is record
Kind: Token_Kind;
Value: Buffer_Record;
end record;
-- Temporary Object Pointer to preserve during GC
type Top_Datum is access all Object_Pointer;
type Top_Array is array(Object_Index range<>) of Top_Datum;
type Top_Record is record
Last: Object_Size := 0;
Data: Top_Array(1 .. 100) := (others => null);
end record;
type Interpreter_State is mod 2 ** 4;
Force_Syntax_Check: constant Interpreter_State := Interpreter_State'(2#0001#);
--type Interpreter_Record is tagged limited record
type Interpreter_Record is limited record
Self: Interpreter_Pointer := Interpreter_Record'Unchecked_Access; -- Current instance's pointer
State: Interpreter_State := 0; -- Internal housekeeping state
Storage_Pool: Storage_Pool_Pointer := null;
Trait: Option_Record(Trait_Option);
Stream: Option_Record(Stream_Option);
Heap: Heap_Pointer_Array := (others => null);
Current_Heap: Heap_Number := Heap_Number'First;
Symbol_Table: Object_Pointer := Nil_Pointer;
Root_Environment: Object_Pointer := Nil_Pointer;
Root_Frame: Object_Pointer := Nil_Pointer;
Stack: Object_Pointer := Nil_Pointer;
Arrow_Symbol: Object_Pointer := Nil_Pointer;
Else_Symbol: Object_Pointer := Nil_Pointer;
Quasiquote_Symbol: Object_Pointer := Nil_Pointer;
Quote_Symbol: Object_Pointer := Nil_Pointer;
Top: Top_Record; -- temporary object pointers
Base_Input: aliased IO_Record;
Input: IO_Pointer := null;
Token: Token_Record;
LC_Unfetched: Standard.Boolean := Standard.False;
end record;
package Token is
procedure Purge (Interp: in out Interpreter_Record);
pragma Inline (Purge);
procedure Set (Interp: in out Interpreter_Record;
Kind: in Token_Kind);
procedure Set (Interp: in out Interpreter_Record;
Kind: in Token_Kind;
Value: in Object_Character);
procedure Set (Interp: in out Interpreter_Record;
Kind: in Token_Kind;
Value: in Object_Character_Array);
procedure Append_String (Interp: in out Interpreter_Record;
Value: in Object_Character_Array);
pragma Inline (Append_String);
procedure Append_Character (Interp: in out Interpreter_Record;
Value: in Object_Character);
pragma Inline (Append_Character);
end Token;
package Bigint is
subtype Object_Radix is Object_Word range 2 .. 36;
function Get_Low (W: Object_Word) return Object_Half_Word;
function Get_High (W: Object_Word) return Object_Half_Word;
function Make_Word (L: Object_Half_Word;
H: Object_Half_Word) return Object_Word;
pragma Inline (Get_High);
pragma Inline (Get_Low);
pragma Inline (Make_Word);
procedure Add (Interp: in out Interpreter_Record;
X: in Object_Pointer;
Y: in Object_Pointer;
Z: out Object_Pointer);
procedure Subtract (Interp: in out Interpreter_Record;
X: in Object_Pointer;
Y: in Object_Pointer;
Z: out Object_Pointer);
procedure Multiply (Interp: in out Interpreter_Record;
X: in Object_Pointer;
Y: in Object_Pointer;
Z: out Object_Pointer);
procedure Divide (Interp: in out Interpreter_Record;
X: in Object_Pointer;
Y: in Object_Pointer;
Q: out Object_Pointer;
R: out Object_Pointer);
function Compare (Interp: access Interpreter_Record;
X: in Object_Pointer;
Y: in Object_Pointer) return Standard.Integer;
function To_String (Interp: access Interpreter_Record;
X: in Object_Pointer;
Radix: in Object_Radix) return Object_Pointer;
function From_String (Interp: access Interpreter_Record;
X: in Object_Character_Array;
Radix: in Object_Radix) return Object_Pointer;
procedure Initialize;
end Bigint;
end H2.Scheme;
Reference in New Issue View Git Blame Copy Permalink