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 - download

⟦56430d1b2⟧ Ada Source

    Length: 23552 (0x5c00)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Generic_Comm, seg_057d48

Derivation

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

E3 Source Code



with Bounded_String;
with Byte_Defs;
with Byte_String_Io;
with Text_Io;


package body Generic_Comm is


    package Bs renames Bounded_String;
    package Ti renames Text_Io;

    Packet : V_Packet;



    task Client is
        entry Get_Client_Id (Id : out Natural);
        entry Put_Client_Id (Id : Natural);
        entry Dispose;
        entry Send (Type_Message) (Rem_Host : T_Host_Id := Ficus;
                                   Rem_Socket : T_Socket := Orb_Socket;
                                   Msg : String := " ";
                                   Source : Natural := 0;
                                   Target : Natural := 0;
                                   Order : Natural := 1);
    end Client;

    procedure Send (Typ : Type_Message;
                    Rem_Host : T_Host_Id := Ficus;
                    Rem_Socket : T_Socket := Orb_Socket;
                    Msg : String := " ";
                    Source : Natural := 0;
                    Target : Natural := 0;
                    Order : Natural := 1) is
    begin
        Client.Send (Typ) (Rem_Host, Rem_Socket, Msg, Source, Target, Order);
    end Send;

    function Get_Client_Id return Natural is
        Id : Natural;
    begin
        Client.Get_Client_Id (Id);
        return Id;
    end Get_Client_Id;

    procedure Put_Client_Id (Id : Natural) is
    begin
        Client.Put_Client_Id (Id);
    end Put_Client_Id;

    procedure Dispose is
    begin
        Client.Dispose;
    end Dispose;

    task Reception is
        entry Enable_Reception (Delay_Max : Duration);
        entry Disable_Reception (Delay_Max : Duration);
        entry Dispose;
    end Reception;

    task body Client is
        Client_Id : Natural := 0;
        Channel_In : Communication.Object;
        Done : Boolean;
        Ok : Boolean;
    begin
        loop
            select
                when Client_Id /= 0 =>
                    accept Get_Client_Id (Id : out Natural) do
                        Id := Client_Id;
                    end Get_Client_Id;
            or
                accept Put_Client_Id (Id : Natural) do
                    Client_Id := Id;
                end Put_Client_Id;
            or
                accept Dispose do
                    --  Reception.Dispose;
                    Done := True;
                end Dispose;
            or
                accept Send (Registration) (Rem_Host : T_Host_Id := Ficus;
                                            Rem_Socket : T_Socket := Orb_Socket;
                                            Msg : String := " ";
                                            Source : Natural := 0;
                                            Target : Natural := 0;
                                            Order : Natural := 1) do

                    Ti.Put_Line ("-> registration ");
                    Messages.Packaging
                       (Typ => Registration,
                        Content => V_Content (Bs.Value (Msg, Mmax)),
                        Source => Source,
                        Target => Target,
                        Order => Order,
                        Pack => Packet);
                    Reception.Enable_Reception (Delay_Max);
                end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Unregistration)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> unregistration");  
                        Messages.Packaging
                           (Typ => Unregistration,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 11, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);
                        Reception.Disable_Reception (Delay_Max);
                    end Send;
            or
                when Client_Id /= 0 =>
                    accept Send (Query) (Rem_Host : T_Host_Id := Ficus;
                                         Rem_Socket : T_Socket := Orb_Socket;
                                         Msg : String := " ";
                                         Source : Natural := 0;
                                         Target : Natural := 0;
                                         Order : Natural := 1) do
                        Ti.Put_Line ("-> query");

                        Messages.Packaging
                           (Typ => Query,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Publication)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> publication");

                        Messages.Packaging
                           (Typ => Publication,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Request) (Rem_Host : T_Host_Id := Ficus;
                                           Rem_Socket : T_Socket := Orb_Socket;
                                           Msg : String := " ";
                                           Source : Natural := 0;
                                           Target : Natural := 0;
                                           Order : Natural := 1) do
                        Ti.Put_Line ("-> request");

                        Messages.Packaging
                           (Typ => Request,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Forward) (Rem_Host : T_Host_Id := Ficus;
                                           Rem_Socket : T_Socket := Orb_Socket;
                                           Msg : String := " ";
                                           Source : Natural := 0;
                                           Target : Natural := 0;
                                           Order : Natural := 1) do
                        Ti.Put_Line ("-> forward");

                        Messages.Packaging
                           (Typ => Forward,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;  
            or  
                when Client_Id /= 0 =>
                    accept Send (Unpublication)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> unpublication");
                        Messages.Packaging
                           (Typ => Unpublication,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Subscription)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> subscription");
                        Messages.Packaging
                           (Typ => Subscription,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;  
            or  
                when Client_Id /= 0 =>
                    accept Send (Unsubscription)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> unsubcription");
                        Messages.Packaging
                           (Typ => Unsubscription,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;  
            or  
                when Client_Id /= 0 =>
                    accept Send (Filtration)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> filtration");
                        Messages.Packaging
                           (Typ => Filtration,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            or  
                when Client_Id /= 0 =>
                    accept Send (Unfiltration)
                              (Rem_Host : T_Host_Id := Ficus;
                               Rem_Socket : T_Socket := Orb_Socket;
                               Msg : String := " ";
                               Source : Natural := 0;
                               Target : Natural := 0;
                               Order : Natural := 1) do
                        Ti.Put_Line ("-> unfiltration");
                        Messages.Packaging
                           (Typ => Unfiltration,
                            Content => V_Content (Bs.Value (Msg, Mmax)),
                            Source => Source,
                            Target => Target,
                            Order => Order,
                            Pack => Packet);
                        Communication.Open_Connection (Channel_In);
                        Communication.Send (Channel_In, Packet, Ficus,
                                            Orb_Socket, 12, Delay_Max,
                                            Success => Ok);
                        Communication.Close_Connection (Channel_In);  
                    end Send;
            end select;
        end loop;
    end Client;



    task body Reception is
        Channel_Out, Channel : Communication.Object;
        Activate : Boolean := False;
        Done : Boolean := False;
        Byte_Msg : Byte_String_Io.Byte_String (0 .. Pmax - 1);
        Counter : Natural;  
        Rec_Msg : Messages.Obj_Msg;
        Ok : Boolean;
    begin
        loop
            select  
                accept Enable_Reception (Delay_Max : Duration) do
                    Communication.Open_Connection (Channel_Out);
                    Messages.Packaging
                       (Typ => Registration,
                        Content =>
                           V_Content
                              (Bs.Value
                                  ("******* message registration ********",
                                   Mmax)),
                        Pack => Packet);
                    Communication.Open_Connection (Channel);
                    Communication.Send
                       (C => Channel,
                        V_Msg => Packet,
                        R_Host => Ficus,
                        R_Socket => Orb_Socket,
                        Try_Nb => 1,
                        Delaymax => Delay_Max,
                        L_Host => Communication.Get_Local_Host (Channel_Out),
                        L_Socket => Communication.Get_Local_Socket
                                       (Channel_Out),
                        Success => Ok);
                    Communication.Close_Connection (Channel);
                    Activate := True;
                end Enable_Reception;
            or
                accept Disable_Reception (Delay_Max : Duration) do
                    Communication.Close_Connection (Channel_Out);
                    Activate := False;
                    Done := True;
                end Disable_Reception;  
            or
                accept Dispose;  
                Done := True;
            else  
                if Activate then
                    Communication.Reception (Delaymax => Delay_Max,
                                             Msg => Byte_Msg,
                                             Count => Counter,
                                             C => Channel_Out);
                    if Counter > 0 then
                        Messages.Unpackaging (Byte_Msg, Counter, Rec_Msg);

                        case Messages.Get_Type_Msg (Rec_Msg) is
                            when Registration =>
                                Client.Put_Client_Id
                                   (Messages.Get_Source_Id (Rec_Msg));
                            when others =>
                                null;
                        end case;

                        Msg_Bal.Put_Message (Rec_Msg);
                    end if;
                end if;
            end select;  
            exit when Done;
        end loop;
    end Reception;
end Generic_Comm;

E3 Meta Data

    nblk1=16
    nid=4
    hdr6=2a
        [0x00] rec0=22 rec1=00 rec2=01 rec3=04e
        [0x01] rec0=26 rec1=00 rec2=10 rec3=042
        [0x02] rec0=16 rec1=00 rec2=0a rec3=042
        [0x03] rec0=14 rec1=00 rec2=06 rec3=064
        [0x04] rec0=08 rec1=00 rec2=02 rec3=068
        [0x05] rec0=13 rec1=00 rec2=03 rec3=02a
        [0x06] rec0=12 rec1=00 rec2=14 rec3=058
        [0x07] rec0=13 rec1=00 rec2=15 rec3=050
        [0x08] rec0=00 rec1=00 rec2=09 rec3=006
        [0x09] rec0=12 rec1=00 rec2=08 rec3=032
        [0x0a] rec0=13 rec1=00 rec2=0d rec3=04c
        [0x0b] rec0=12 rec1=00 rec2=05 rec3=050
        [0x0c] rec0=13 rec1=00 rec2=13 rec3=024
        [0x0d] rec0=12 rec1=00 rec2=12 rec3=070
        [0x0e] rec0=12 rec1=00 rec2=16 rec3=00c
        [0x0f] rec0=13 rec1=00 rec2=0f rec3=04e
        [0x10] rec0=12 rec1=00 rec2=07 rec3=05a
        [0x11] rec0=1b rec1=00 rec2=0c rec3=06c
        [0x12] rec0=12 rec1=00 rec2=0b rec3=02e
        [0x13] rec0=15 rec1=00 rec2=0e rec3=046
        [0x14] rec0=14 rec1=00 rec2=11 rec3=000
        [0x15] rec0=18 rec1=00 rec2=0c rec3=001
    tail 0x21765194a87d243ae4e51 0x42a00088462060003
Free Block Chain:
  0x4: 0000  00 00 00 04 80 01 20 01 02 03 20 20 20 20 20 20  ┆                ┆