DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ B T

⟦47334b127⟧ TextFile

    Length: 4170 (0x104a)
    Types: TextFile
    Names: »B«

Derivation

└─⟦afbc8121e⟧ Bits:30000532 8mm tape, Rational 1000, MC68020_OS2000 7_2_2
    └─ ⟦77aa8350c⟧ »DATA« 
        └─⟦f794ecd1d⟧ 
            └─⟦4c85d69e2⟧ 
                └─⟦this⟧ 

TextFile

package body System is

    package Implementation is

        function Unsigned_Add      (Left, Right : Integer) return Integer;
        function Unsigned_Subtract (Left, Right : Integer) return Integer;

        function Unsigned_Lt (Left, Right : Address) return Boolean;
        function Unsigned_Le (Left, Right : Address) return Boolean;
        function Unsigned_Gt (Left, Right : Address) return Boolean;
        function Unsigned_Ge (Left, Right : Address) return Boolean;

    private

        pragma Suppress (Elaboration_Check, On => Unsigned_Add);
        pragma Interface (Asm, Unsigned_Add);
        pragma Import_Function (Internal  => Unsigned_Add,
                                External  => "__SYSTEM.UNSIGNED_ADD",
                                Mechanism => Value);

        pragma Interface (Asm, Unsigned_Subtract);
        pragma Suppress (Elaboration_Check, On => Unsigned_Subtract);
        pragma Import_Function (Internal  => Unsigned_Subtract,
                                External  => "__SYSTEM.UNSIGNED_SUBTRACT",
                                Mechanism => Value);

        pragma Interface (Asm, Unsigned_Lt);
        pragma Suppress (Elaboration_Check, On => Unsigned_Lt);
        pragma Import_Function (Internal  => Unsigned_Lt,  
                                External  => "__SYSTEM.UNSIGNED_LT",
                                Mechanism => Value);

        pragma Interface (Asm, Unsigned_Le);
        pragma Suppress (Elaboration_Check, On => Unsigned_Le);
        pragma Import_Function (Internal  => Unsigned_Le,  
                                External  => "__SYSTEM.UNSIGNED_LE",
                                Mechanism => Value);

        pragma Interface (Asm, Unsigned_Gt);
        pragma Suppress (Elaboration_Check, On => Unsigned_Gt);
        pragma Import_Function (Internal  => Unsigned_Gt,  
                                External  => "__SYSTEM.UNSIGNED_GT",
                                Mechanism => Value);

        pragma Interface (Asm, Unsigned_Ge);
        pragma Suppress (Elaboration_Check, On => Unsigned_Ge);
        pragma Import_Function (Internal  => Unsigned_Ge,  
                                External  => "__SYSTEM.UNSIGNED_GE",
                                Mechanism => Value);

    end Implementation;

    function To_Address (Value : Integer) return Address is
    begin
        return Address (Value);
    end To_Address;

    function To_Integer (Value : Address) return Integer is
    begin
        return Integer (Value);
    end To_Integer;

    function "+" (Left : Address; Right : Integer) return Address is
    begin
        return Address (Implementation.Unsigned_Add (Left  => Integer (Left),  
                                                     Right => Right));
    end "+";

    function "+" (Left : Integer; Right : Address) return Address is
    begin
        return Address (Implementation.Unsigned_Add (Left  => Left,  
                                                     Right => Integer (Right)));
    end "+";

    function "-" (Left : Address; Right : Address) return Integer is
    begin
        return Implementation.Unsigned_Subtract (Left  => Integer (Left),  
                                                 Right => Integer (Right));
    end "-";

    function "-" (Left : Address; Right : Integer) return Address is
    begin
        return Address (Implementation.Unsigned_Subtract
                           (Left  => Integer (Left),  
                            Right => Right));
    end "-";

    function "<" (Left, Right : Address) return Boolean is
    begin
        return Implementation.Unsigned_Lt (Left => Left, Right => Right);
    end "<";

    function "<=" (Left, Right : Address) return Boolean is
    begin
        return Implementation.Unsigned_Le (Left => Left, Right => Right);
    end "<=";

    function ">" (Left, Right : Address) return Boolean is
    begin
        return Implementation.Unsigned_Gt (Left => Left, Right => Right);
    end ">";

    function ">=" (Left, Right : Address) return Boolean is
    begin
        return Implementation.Unsigned_Ge (Left => Left, Right => Right);
    end ">=";

end System;