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

⟦6eae2d75d⟧ Ada Source

    Length: 17408 (0x4400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Z_Debug, seg_020f1f

Derivation

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

E3 Source Code



with Bus;
with D_Gui_Driver;
with Desassembleur;
with Gui_Interface;
with Memoire;
with Mot;
with Octet;
with Registres;
with Xt_Interface;
with Z80_Defs;
with Point_D_Arret;
with Z80;
with Z_Debug_Tache;

package body Z_Debug is
    --------------------------------------------------------------------------

    procedure Je_Teste is

    begin

        Gui_Interface.Init;

        Memoire.Creer;
        Bus.Creer;
        Z80.Creer;

        -- prologue
        Registres.Reset;

        Gui_Interface.Set_Message (Message => "Reset");

        Rafraichir_Ecran;

        loop
            D_Gui_Driver.Process_Event;

            if Xt_Interface.Pending then
                Xt_Interface.Next_Event;
                Xt_Interface.Dispatch_Event;
            end if;


        end loop;

    exception

        when D_Gui_Driver.Kill =>
            null;
    end Je_Teste;


    --------------------------------------------------------------------------

    procedure Valider_Memoire is

        I, J : Positive := 1;
        Ligne : Natural := 0;

        Reception_Pointeur : String (1 .. 80) := (others => '#');
        Reception_Dump : String (1 .. 16 * 50) := (others => '0');
        Adresse : Mot.T_Mot;
        Donnee : Octet.T_Octet;

    begin

        Gui_Interface.Iterator_Memory_List;
        Gui_Interface.Iterator.Init;
        I := 1;

        while not Gui_Interface.Iterator.Done loop
            Reception_Pointeur (I) := Gui_Interface.Iterator.Value;
            I := I + 1;
            Gui_Interface.Iterator.Next;
        end loop;


        Gui_Interface.Iterator_Memory_Dump;
        Gui_Interface.Iterator.Init;
        J := 1;

        while not Gui_Interface.Iterator.Done loop
            Reception_Dump (J) := Gui_Interface.Iterator.Value;
            J := J + 1;
            Gui_Interface.Iterator.Next;
        end loop;



        I := 1;
        Ligne := 0;
        while Reception_Pointeur (I) /= '#' loop

            Adresse := Mot.Convert_Ascii_Mot
                          (Reception_Pointeur (I), Reception_Pointeur (I + 1),
                           Reception_Pointeur (I + 2),
                           Reception_Pointeur (I + 3));  
            I := I + 4;


            J := (Ligne * 48) + 1;
            for Compteur_Octet in 1 .. 16 loop

                Donnee := Octet.Convert_Ascii_Octet
                             (Reception_Dump (J), Reception_Dump (J + 1));
                Memoire.Acces_Octet (Memoire.Ecrire, Adresse, Donnee);

                Adresse := Mot.Add (Adresse, Mot.Construire (0, 1));
                J := J + 3;

            end loop;

            Ligne := Ligne + 1;

        end loop;



    end Valider_Memoire;


    --------------------------------------------------------------------------

    procedure Valider_Ecran is

        use Z80_Defs;
        Reception : String (1 .. 80);
        J : Positive := 1;
        Un_Octet : Octet.T_Octet;
        Un_Mot : Mot.T_Mot;
    begin

        -- recuperation de la chaine

        Gui_Interface.Iterator_Z80_Status;

        Gui_Interface.Iterator.Init;

        while not Gui_Interface.Iterator.Done loop
            Reception (J) := Gui_Interface.Iterator.Value;

            J := J + 1;
            Gui_Interface.Iterator.Next;
        end loop;

        --Gui_Interface.Set_Instruction ("ecran lu");


        -- affectation des registres
        Un_Octet := Octet.Convert_Ascii_Octet (Reception (1), Reception (2));
        Registres.Ecrire_Simple (A, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (3), Reception (4));
        Registres.Ecrire_Simple (F, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (5), Reception (6));
        Registres.Ecrire_Simple (B, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (7), Reception (8));
        Registres.Ecrire_Simple (C, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (9), Reception (10));
        Registres.Ecrire_Simple (D, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (11), Reception (12));
        Registres.Ecrire_Simple (E, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (13), Reception (14));
        Registres.Ecrire_Simple (H, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (15), Reception (16));
        Registres.Ecrire_Simple (L, Un_Octet);

        Un_Octet := Octet.Convert_Ascii_Octet (Reception (17), Reception (18));
        Registres.Ecrire_Simple (I, Un_Octet);

        ---------------------
        Un_Mot := Mot.Convert_Ascii_Mot (Reception (19), Reception (20),
                                         Reception (21), Reception (22));
        Registres.Ecrire_Double (Af_Prime, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (23), Reception (24),
                                         Reception (25), Reception (26));
        Registres.Ecrire_Double (Bc_Prime, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (27), Reception (28),
                                         Reception (29), Reception (30));
        Registres.Ecrire_Double (De_Prime, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (31), Reception (32),
                                         Reception (33), Reception (34));
        Registres.Ecrire_Double (Hl_Prime, Un_Mot);

        ---------------------
        Un_Mot := Mot.Convert_Ascii_Mot (Reception (35), Reception (36),
                                         Reception (37), Reception (38));
        Registres.Ecrire_Double (Ix, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (39), Reception (40),
                                         Reception (41), Reception (42));
        Registres.Ecrire_Double (Iy, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (43), Reception (44),
                                         Reception (45), Reception (46));
        Registres.Ecrire_Double (Sp, Un_Mot);

        Un_Mot := Mot.Convert_Ascii_Mot (Reception (47), Reception (48),
                                         Reception (49), Reception (50));
        Registres.Ecrire_Double (Pc, Un_Mot);


        -- recuperation de la chaine des points d arret

        Gui_Interface.Iterator_Break_List;
        J := 1;

        Gui_Interface.Iterator.Init;

        while not Gui_Interface.Iterator.Done loop
            Reception (J) := Gui_Interface.Iterator.Value;
            J := J + 1;
            Gui_Interface.Iterator.Next;
        end loop;


        Point_D_Arret.Creer;
        J := 1;

        for Numero in Point_D_Arret.T_Taille_Liste loop

            if Reception (J) /= '#' then  
                Un_Mot := Mot.Convert_Ascii_Mot
                             (Reception (J), Reception (J + 1),
                              Reception (J + 2), Reception (J + 3));
                Point_D_Arret.Mise_A_Jour_Liste (Un_Mot, Numero);
            end if;  
            J := J + 4;

        end loop;


        -- Lecture du Dump Memoire ------------------------

        Valider_Memoire;


    end Valider_Ecran;
    -------------------------------------------------------------------------

    procedure Rafraichir_Memoire is

        I, J : Positive := 1;

        Reception : String (1 .. 80) := (others => '#');
        Emission : String (1 .. 36) := (others => '0');
        Adresse : Mot.T_Mot;
        Donnee : Octet.T_Octet;

    begin

        Gui_Interface.Iterator_Memory_List;
        Gui_Interface.Iterator.Init;
        I := 1;

        while not Gui_Interface.Iterator.Done loop
            Reception (I) := Gui_Interface.Iterator.Value;
            I := I + 1;
            Gui_Interface.Iterator.Next;
        end loop;


        Gui_Interface.Delete_Memory_Dump;

        I := 1;
        while Reception (I) /= '#' loop

            Adresse := Mot.Convert_Ascii_Mot
                          (Reception (I), Reception (I + 1),
                           Reception (I + 2), Reception (I + 3));  
            I := I + 4;

            for J in 1 .. 4 loop  
                Emission (J) := Reception ((I + J) - 1);
            end loop;

            J := 5;
            for Compteur_Octet in 1 .. 16 loop

                Memoire.Acces_Octet (Memoire.Lire, Adresse, Donnee);
                Octet.Convert_Octet_Ascii
                   (Donnee, Emission (J), Emission (J + 1));
                J := J + 2;  
                Adresse := Mot.Add (Adresse, Mot.Construire (0, 1));

            end loop;

            Gui_Interface.Set_Memory_Line (Emission);

        end loop;

        Gui_Interface.Display_Memory_Dump;

    end Rafraichir_Memoire;
    --------------------------------------------------------------------------

    procedure Rafraichir_Ecran is

        use Z80_Defs;
        Emission : String (1 .. 56) := (others => ' ');
        J : Positive := 1;
        Un_Octet : Octet.T_Octet;
        Un_Mot : Mot.T_Mot;
        Reg_Ix, Reg_Iy, Reg_Sp, Reg_Pc : Mot.T_Mot;
        Trouvee : Boolean := False;

    begin

        Un_Octet := Registres.Lire_Simple (A);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (F);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (B);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (C);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (D);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;
       Un_Octet := Registres.Lire_Simple (E);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (H);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (L);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Octet := Registres.Lire_Simple (I);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Un_Mot := Registres.Lire_Double (Af_Prime);
        Mot.Convert_Mot_Ascii (Un_Mot, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Un_Mot := Registres.Lire_Double (Bc_Prime);
        Mot.Convert_Mot_Ascii (Un_Mot, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Un_Mot := Registres.Lire_Double (De_Prime);
        Mot.Convert_Mot_Ascii (Un_Mot, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Un_Mot := Registres.Lire_Double (Hl_Prime);
        Mot.Convert_Mot_Ascii (Un_Mot, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Reg_Ix := Registres.Lire_Double (Ix);
        Mot.Convert_Mot_Ascii (Reg_Ix, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Reg_Iy := Registres.Lire_Double (Iy);
        Mot.Convert_Mot_Ascii (Reg_Iy, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Reg_Sp := Registres.Lire_Double (Sp);
        Mot.Convert_Mot_Ascii (Reg_Sp, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Reg_Pc := Registres.Lire_Double (Pc);
        Mot.Convert_Mot_Ascii (Reg_Pc, Emission (J), Emission (J + 1),
                               Emission (J + 2), Emission (J + 3));
        J := J + 4;

        Memoire.Acces_Octet (Memoire.Lire, Reg_Ix, Un_Octet);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Memoire.Acces_Octet (Memoire.Lire, Reg_Iy, Un_Octet);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        Memoire.Acces_Octet (Memoire.Lire, Reg_Sp, Un_Octet);
        Octet.Convert_Octet_Ascii (Un_Octet, Emission (J), Emission (J + 1));
        J := J + 2;

        -- Recherche de l'instruction_suivante

        while not Trouvee loop
            Memoire.Acces_Octet (Memoire.Lire, Reg_Pc, Un_Octet);
            Reg_Pc := Mot.Add (Reg_Pc, 1);
            Trouvee := Desassembleur.Traiter_Code (Un_Octet);
        end loop;

        Gui_Interface.Set_Instruction (Desassembleur.Instruction_En_Texte);

        Gui_Interface.Update (Emission);

        Rafraichir_Memoire;


    end Rafraichir_Ecran;





end Z_Debug;

E3 Meta Data

    nblk1=10
    nid=0
    hdr6=20
        [0x00] rec0=36 rec1=00 rec2=01 rec3=040
        [0x01] rec0=22 rec1=00 rec2=0b rec3=000
        [0x02] rec0=25 rec1=00 rec2=03 rec3=03c
        [0x03] rec0=23 rec1=00 rec2=05 rec3=004
        [0x04] rec0=03 rec1=00 rec2=04 rec3=00a
        [0x05] rec0=15 rec1=00 rec2=09 rec3=04c
        [0x06] rec0=14 rec1=00 rec2=0c rec3=08c
        [0x07] rec0=1f rec1=00 rec2=0e rec3=038
        [0x08] rec0=26 rec1=00 rec2=02 rec3=03c
        [0x09] rec0=05 rec1=00 rec2=0d rec3=030
        [0x0a] rec0=20 rec1=00 rec2=08 rec3=022
        [0x0b] rec0=1d rec1=00 rec2=07 rec3=002
        [0x0c] rec0=17 rec1=00 rec2=0a rec3=06a
        [0x0d] rec0=18 rec1=00 rec2=06 rec3=066
        [0x0e] rec0=19 rec1=00 rec2=10 rec3=030
        [0x0f] rec0=12 rec1=00 rec2=0f rec3=000
    tail 0x2150d31648240854137c7 0x42a00088462060003