DataMuseum.dk Presents historical artifacts from the history of: Rational R1000/400

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 Excavated with: AutoArchaeologist - Free & Open Source Software.

top - metrics - download

⟦4cb0d757d⟧ Ada Source

    Length: 28672 (0x7000)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Exe_100, package body Test_Func_In, package body Test_Func_In10, package body Test_Func_In5, package body Test_Func_In_In_In, package body Test_Func_In_In_In_X_String, package body Test_Func_In_X_String, package body Test_Proc_In, package body Test_Proc_In10, package body Test_Proc_In_In, package body Test_Proc_In_In_In, package body Test_Proc_In_In_In_In, package body Test_Proc_In_In_In_Out_Out, package body Test_Proc_In_In_Out_Out, package body Test_Proc_Inout, seg_00555b

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

with Xlbt_Proc_Var;  
use Xlbt_Proc_Var;  
with Xlbt_String;  
use Xlbt_String;

with Test_Io;  
use Test_Io;

package body Exe_100 is

------------------------------------------------------------------------------
-- Test Procedure Variables - for Procedure types
------------------------------------------------------------------------------

--\x0c
    procedure Assert (Hypothesis : Boolean) is  
        Something_Wrong : exception;  
    begin  
        if not Hypothesis then  
            raise Something_Wrong;  
        end if;  
    end Assert;

--\x0c
    function Value return X_String is  
        A : constant X_String := To_X_String ("x_string");  
    begin  
        return A;  
    end Value;

    function Value (Arg : X_String) return Boolean is  
    begin  
        return Arg = To_X_String ("x_string");  
    end Value;

--\x0c
    function Value return Access_Type is  
        A : Access_Type := new Boolean'(False);     begin  
        return A;  
    end Value;

    function Out_Value return Access_Type is  
        A : Access_Type := new Boolean'(True);  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Access_Type) return Boolean is  
    begin  
        return Arg.all = False;  
    end Value;

    function Out_Value (Arg : Access_Type) return Boolean is  
    begin  
        return Arg.all = True;  
    end Out_Value;

--\x0c
    function Value return Enumeration_Type is  
        A : Enumeration_Type := Enumeration_Type'First;  
    begin  
        return A;  
    end Value;

    function Out_Value return Enumeration_Type is  
        A : Enumeration_Type := Enumeration_Type'Last;  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Enumeration_Type) return Boolean is  
    begin  
        return Arg = Enumeration_Type'First;  
    end Value;

    function Out_Value (Arg : Enumeration_Type) return Boolean is  
    begin  
        return Arg = Enumeration_Type'Last;  
    end Out_Value;

--\x0c
    function Value return Boolean_Type is  
        A : Boolean_Type := Boolean_Type'First;  
    begin  
        return A;  
    end Value;

    function Out_Value return Boolean_Type is  
        A : Boolean_Type := Boolean_Type'Last;  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Boolean_Type) return Boolean is  
    begin  
        return Arg = Boolean_Type'First;  
    end Value;

    function Out_Value (Arg : Boolean_Type) return Boolean is  
    begin  
        return Arg = Boolean_Type'Last;  
    end Out_Value;

--\x0c
    function Value return Fixed_Type is  
        A : Fixed_Type := Fixed_Type'First;  
    begin  
        return A;  
    end Value;

    function Out_Value return Fixed_Type is  
        A : Fixed_Type := Fixed_Type'Last;  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Fixed_Type) return Boolean is  
    begin  
        return Arg = Fixed_Type'First;  
    end Value;

    function Out_Value (Arg : Fixed_Type) return Boolean is  
    begin  
        return Arg = Fixed_Type'Last;  
    end Out_Value;

--\x0c
    function Value return Float_Type is  
        A : Float_Type := Float_Type'First;  
    begin  
        return A;  
    end Value;

    function Out_Value return Float_Type is  
        A : Float_Type := Float_Type'Last;  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Float_Type) return Boolean is  
    begin  
        return Arg = Float_Type'First;  
    end Value;

    function Out_Value (Arg : Float_Type) return Boolean is  
    begin  
        return Arg = Float_Type'Last;  
    end Out_Value;

--\x0c
    function Value return Constrained_Record_Type is  
        A : Constrained_Record_Type := (S => "aaaaaaaaaa");  
    begin  
        return A;  
    end Value;

    function Out_Value return Constrained_Record_Type is  
        A : Constrained_Record_Type := (S => "zzzzzzzzzz");  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Constrained_Record_Type) return Boolean is  
    begin  
        return Arg.S = "aaaaaaaaaa";  
    end Value;

    function Out_Value (Arg : Constrained_Record_Type) return Boolean is  
    begin  
        return Arg.S = "zzzzzzzzzz";  
    end Out_Value;

--\x0c
    function Value return Unconstrained_Record_Type is  
        A : Unconstrained_Record_Type (10) := (D => 10, S => "aaaaaaaaaa");  
    begin  
        return A;  
    end Value;

    function Out_Value return Unconstrained_Record_Type is  
        A : Unconstrained_Record_Type (10) := (D => 10, S => "zzzzzzzzzz");  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Unconstrained_Record_Type) return Boolean is  
    begin  
        return Arg.S = "aaaaaaaaaa";  
    end Value;

    function Out_Value (Arg : Unconstrained_Record_Type) return Boolean is  
    begin  
        return Arg.S = "zzzzzzzzzz";  
    end Out_Value;

--\x0c
    function Value return Constrained_String_Type is  
        A : Constrained_String_Type := "aaaaaaaaaa";  
    begin  
        return A;  
    end Value;

    function Out_Value return Constrained_String_Type is  
        A : Constrained_String_Type := "zzzzzzzzzz";  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Constrained_String_Type) return Boolean is  
    begin  
        return Arg = "aaaaaaaaaa";  
    end Value;

    function Out_Value (Arg : Constrained_String_Type) return Boolean is  
    begin  
        return Arg = "zzzzzzzzzz";  
    end Out_Value;

--\x0c
    function Value return Unconstrained_String_Type is  
        A : Unconstrained_String_Type (1 .. 10) := "aaaaaaaaaa";  
    begin  
        return A;  
    end Value;

    function Out_Value return Unconstrained_String_Type is  
        A : Unconstrained_String_Type (1 .. 10) := "zzzzzzzzzz";  
    begin  
        return A;  
    end Out_Value;

    function Value (Arg : Unconstrained_String_Type) return Boolean is  
    begin  
        return Arg = "aaaaaaaaaa";  
    end Value;

    function Out_Value (Arg : Unconstrained_String_Type) return Boolean is  
    begin  
        return Arg = "zzzzzzzzzz";  
    end Out_Value;

--\x0c
    package body Test_Proc_Inout is

        procedure Real_Op (Arg1 : in out Argument_Type);

        package Pack is new Proc_Inout (Argument_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in out Argument_Type) is  
        begin  
            Assert (Value (Arg1));  
            Arg1 := Out_Value;

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_Inout");

            Arg1 := Value;  
            Real_Op (Arg1);  
            Assert (Out_Value (Arg1));

            Executed_Real_Op := False;

            Arg1 := Value;  
            Pack.Call (Pvv, Arg1);  
            Assert (Out_Value (Arg1));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_Inout;

--\x0c
    package body Test_Proc_In is

        procedure Real_Op (Arg1 : in Argument_Type);

        package Pack is new Proc_In (Argument_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in Argument_Type) is  
        begin  
            Assert (Value (Arg1));

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In");

            Real_Op (Value);

            Executed_Real_Op := False;

            Pack.Call (Pvv, Value);

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In;

--\x0c
    package body Test_Proc_In_In is

        procedure Real_Op (Arg1 : in Argument1_Type; Arg2 : in Argument2_Type);

        package Pack is new Proc_In_In (Argument1_Type, Argument2_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in Argument1_Type;  
                           Arg2 : in Argument2_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In_In");

            Real_Op (Value, Value);

            Executed_Real_Op := False;

            Pack.Call (Pvv, Value, Value);

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In_In;

--\x0c
    package body Test_Proc_In_In_In is

        procedure Real_Op (Arg1 : in Argument1_Type;  
                           Arg2 : in Argument2_Type;  
                           Arg3 : in Argument3_Type);

        package Pack is new Proc_In_In_In  
                               (Argument1_Type, Argument2_Type, Argument3_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in Argument1_Type;  
                           Arg2 : in Argument2_Type;  
                           Arg3 : in Argument3_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In_In_In");

            Real_Op (Value, Value, Value);

            Executed_Real_Op := False;

            Pack.Call (Pvv, Value, Value, Value);

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In_In_In;

--\x0c
    package body Test_Proc_In_In_In_In is

        procedure Real_Op (Arg1 : in Argument1_Type;  
                           Arg2 : in Argument2_Type;  
                           Arg3 : in Argument3_Type;  
                           Arg4 : in Argument4_Type);

        package Pack is new Proc_In_In_In_In (Argument1_Type, Argument2_Type,  
                                              Argument3_Type, Argument4_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in Argument1_Type;  
                           Arg2 : in Argument2_Type;  
                           Arg3 : in Argument3_Type;  
                           Arg4 : in Argument4_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));  
            Assert (Value (Arg4));

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In_In_In_In");

            Real_Op (Value, Value, Value, Value);

            Executed_Real_Op := False;

            Pack.Call (Pvv, Value, Value, Value, Value);

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In_In_In_In;

--\x0c
    package body Test_Proc_In10 is

        procedure Real_Op (Arg1  : in Argument1_Type;  
                           Arg2  : in Argument2_Type;  
                           Arg3  : in Argument3_Type;  
                           Arg4  : in Argument4_Type;  
                           Arg5  : in Argument5_Type;  
                           Arg6  : in Argument6_Type;  
                           Arg7  : in Argument7_Type;  
                           Arg8  : in Argument8_Type;  
                           Arg9  : in Argument9_Type;  
                           Arg10 : in Argument10_Type);

        package Pack is new Proc_In10 (Argument1_Type, Argument2_Type,  
                                       Argument3_Type, Argument4_Type,  
                                       Argument5_Type, Argument6_Type,  
                                       Argument7_Type, Argument8_Type,  
                                       Argument9_Type, Argument10_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1  : in Argument1_Type;  
                           Arg2  : in Argument2_Type;  
                           Arg3  : in Argument3_Type;  
                           Arg4  : in Argument4_Type;  
                           Arg5  : in Argument5_Type;  
                           Arg6  : in Argument6_Type;  
                           Arg7  : in Argument7_Type;  
                           Arg8  : in Argument8_Type;  
                           Arg9  : in Argument9_Type;  
                           Arg10 : in Argument10_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));  
            Assert (Value (Arg4));  
            Assert (Value (Arg5));  
            Assert (Value (Arg6));  
            Assert (Value (Arg7));  
            Assert (Value (Arg8));  
            Assert (Value (Arg9));  
            Assert (Value (Arg10));

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In10");

            Real_Op (Value, Value, Value, Value, Value,  
                     Value, Value, Value, Value, Value);

            Executed_Real_Op := False;

            Pack.Call (Pvv, Value, Value, Value, Value, Value,  
                       Value, Value, Value, Value, Value);

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In10;

--\x0c
    package body Test_Proc_In_In_In_Out_Out is

        procedure Real_Op (Arg1 : in  Argument1_Type;  
                           Arg2 : in  Argument2_Type;  
                           Arg3 : in  Argument3_Type;  
                           Arg4 : out Argument4_Type;  
                           Arg5 : out Argument5_Type);

        package Pack is new Proc_In_In_In_Out_Out  
                               (Argument1_Type, Argument2_Type, Argument3_Type,  
                                Argument4_Type, Argument5_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in  Argument1_Type;  
                           Arg2 : in  Argument2_Type;  
                           Arg3 : in  Argument3_Type;  
                           Arg4 : out Argument4_Type;  
                           Arg5 : out Argument5_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));

            Arg4 := Out_Value;  
            Arg5 := Out_Value;

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In_In_In_Out_Out");

            Real_Op (Value, Value, Value, Arg4, Arg5);

            Assert (Out_Value (Arg4));  
            Assert (Out_Value (Arg5));

            Executed_Real_Op := False;

            Arg4 := Value;  
            Arg5 := Value;  
            Pack.Call (Pvv, Value, Value, Value, Arg4, Arg5);

            Assert (Out_Value (Arg4));  
            Assert (Out_Value (Arg5));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In_In_In_Out_Out;

--\x0c
    package body Test_Proc_In_In_Out_Out is

        procedure Real_Op (Arg1 : in  Argument1_Type;  
                           Arg2 : in  Argument2_Type;  
                           Arg3 : out Argument3_Type;  
                           Arg4 : out Argument4_Type);

        package Pack is new Proc_In_In_Out_Out (Argument1_Type, Argument2_Type,  
                                                Argument3_Type, Argument4_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        procedure Real_Op (Arg1 : in  Argument1_Type;  
                           Arg2 : in  Argument2_Type;  
                           Arg3 : out Argument3_Type;  
                           Arg4 : out Argument4_Type) is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));

            Arg3 := Out_Value;  
            Arg4 := Out_Value;

            Executed_Real_Op := True;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Proc_In_In_Out_Out");

            Real_Op (Value, Value, Arg3, Arg4);

            Assert (Out_Value (Arg3));  
            Assert (Out_Value (Arg4));  
            Executed_Real_Op := False;

            Arg3 := Value;  
            Arg4 := Value;  
            Pack.Call (Pvv, Value, Value, Arg3, Arg4);

            Assert (Out_Value (Arg3));  
            Assert (Out_Value (Arg4));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;

    end Test_Proc_In_In_Out_Out;

--\x0c
    package body Test_Func_In is

        function Real_Op (Arg1 : in Argument_Type) return Result_Type;

        package Pack is new Func_In (Argument_Type, Result_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1 : in Argument_Type) return Result_Type is  
        begin  
            Assert (Value (Arg1));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In;

--\x0c
    package body Test_Func_In_X_String is

        function Real_Op (Arg1 : in Argument_Type) return X_String;

        package Pack is new Func_In_X_String (Argument_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1 : in Argument_Type) return X_String is  
        begin  
            Assert (Value (Arg1));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In_X_String");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In_X_String;

--\x0c
    package body Test_Func_In_In_In_X_String is

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type) return X_String;

        package Pack is new Func_In_In_In_X_String  
                               (Argument1_Type, Argument2_Type, Argument3_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type) return X_String is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In_In_In_X_String");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value, Value, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In_In_In_X_String;

--\x0c
    package body Test_Func_In_In_In is

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type) return Result_Type;

        package Pack is new Func_In_In_In (Argument1_Type, Argument2_Type,  
                                           Argument3_Type, Result_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type) return Result_Type is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In_In_In");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value, Value, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In_In_In;

--\x0c
    package body Test_Func_In5 is

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type;  
                          Arg4 : in Argument4_Type;  
                          Arg5 : in Argument5_Type) return Result_Type;

        package Pack is new Func_In5 (Argument1_Type, Argument2_Type,  
                                      Argument3_Type, Argument4_Type,  
                                      Argument5_Type, Result_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1 : in Argument1_Type;  
                          Arg2 : in Argument2_Type;  
                          Arg3 : in Argument3_Type;  
                          Arg4 : in Argument4_Type;  
                          Arg5 : in Argument5_Type) return Result_Type is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));  
            Assert (Value (Arg4));  
            Assert (Value (Arg5));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In5");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value, Value, Value, Value, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In5;

--\x0c
    package body Test_Func_In10 is

        function Real_Op (Arg1  : in Argument1_Type;  
                          Arg2  : in Argument2_Type;  
                          Arg3  : in Argument3_Type;  
                          Arg4  : in Argument4_Type;  
                          Arg5  : in Argument5_Type;  
                          Arg6  : in Argument6_Type;  
                          Arg7  : in Argument7_Type;  
                          Arg8  : in Argument8_Type;  
                          Arg9  : in Argument9_Type;  
                          Arg10 : in Argument10_Type) return Result_Type;

        package Pack is new Func_In10  
                               (Argument1_Type, Argument2_Type, Argument3_Type,  
                                Argument4_Type, Argument5_Type, Argument6_Type,  
                                Argument7_Type, Argument8_Type,  
                                Argument9_Type, Argument10_Type, Result_Type);

        function Pack_Value is new Pack.Value (Real_Op);  
        Pvv : Pack.Pv := Pack_Value;

        function Real_Op (Arg1  : in Argument1_Type;  
                          Arg2  : in Argument2_Type;  
                          Arg3  : in Argument3_Type;  
                          Arg4  : in Argument4_Type;  
                          Arg5  : in Argument5_Type;  
                          Arg6  : in Argument6_Type;  
                          Arg7  : in Argument7_Type;  
                          Arg8  : in Argument8_Type;  
                          Arg9  : in Argument9_Type;  
                          Arg10 : in Argument10_Type) return Result_Type is  
        begin  
            Assert (Value (Arg1));  
            Assert (Value (Arg2));  
            Assert (Value (Arg3));  
            Assert (Value (Arg4));  
            Assert (Value (Arg5));  
            Assert (Value (Arg6));  
            Assert (Value (Arg7));  
            Assert (Value (Arg8));  
            Assert (Value (Arg9));  
            Assert (Value (Arg10));

            Executed_Real_Op := True;

            return Value;  
        end Real_Op;

        procedure Zot is  
        begin  
            Put_Line ("Test_Func_In10");  
            Executed_Real_Op := False;

            Assert (Value (Pack.Call (Pvv, Value, Value, Value, Value, Value,  
                                      Value, Value, Value, Value, Value)));

            Assert (Executed_Real_Op);  
            Pack.Free (Pvv);  
        end Zot;  
    end Test_Func_In10;

--\x0c
end Exe_100;  

    nblk1=1b
    nid=0
    hdr6=36
        [0x00] rec0=28 rec1=00 rec2=01 rec3=002
        [0x01] rec0=26 rec1=00 rec2=02 rec3=04e
        [0x02] rec0=27 rec1=00 rec2=03 rec3=00a
        [0x03] rec0=25 rec1=00 rec2=04 rec3=07a
        [0x04] rec0=22 rec1=00 rec2=05 rec3=088
        [0x05] rec0=23 rec1=00 rec2=06 rec3=074
        [0x06] rec0=24 rec1=00 rec2=07 rec3=032
        [0x07] rec0=29 rec1=00 rec2=08 rec3=014
        [0x08] rec0=26 rec1=00 rec2=09 rec3=040
        [0x09] rec0=21 rec1=00 rec2=0a rec3=028
        [0x0a] rec0=21 rec1=00 rec2=0b rec3=054
        [0x0b] rec0=22 rec1=00 rec2=0c rec3=038
        [0x0c] rec0=13 rec1=00 rec2=0d rec3=04e
        [0x0d] rec0=1a rec1=00 rec2=0e rec3=00a
        [0x0e] rec0=1b rec1=00 rec2=0f rec3=080
        [0x0f] rec0=21 rec1=00 rec2=10 rec3=020
        [0x10] rec0=1c rec1=00 rec2=11 rec3=03e
        [0x11] rec0=26 rec1=00 rec2=12 rec3=026
        [0x12] rec0=23 rec1=00 rec2=13 rec3=056
        [0x13] rec0=22 rec1=00 rec2=14 rec3=00c
        [0x14] rec0=20 rec1=00 rec2=15 rec3=040
        [0x15] rec0=1d rec1=00 rec2=16 rec3=026
        [0x16] rec0=19 rec1=00 rec2=17 rec3=018
        [0x17] rec0=20 rec1=00 rec2=18 rec3=024
        [0x18] rec0=13 rec1=00 rec2=19 rec3=046
        [0x19] rec0=1b rec1=00 rec2=1a rec3=03a
        [0x1a] rec0=0c rec1=00 rec2=1b rec3=000
    tail 0x217009b5481978bbb9ca7 0x42a00088462063203