|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 11264 (0x2c00)
Types: Ada Source
Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Nos_Listes, seg_046082, seg_0465d7, seg_04696a, seg_0472d1
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─ ⟦5a81ac88f⟧ »Space Info Vol 1«
└─⟦this⟧
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─ ⟦cfc2e13cd⟧ »Space Info Vol 2«
└─⟦this⟧
package body Nos_Listes is
---------------------------------------------------------------
--|
--| Ajoute un element a la liste s'il ne s'y trouve pas deja.
--|
--| Parametres d'entree :
--| L : liste sur laquelle doit etre fait l'ajout
--| (type objet)
--| Item : element a ajouter a la liste
--| (type element)
--|
---------------------------------------------------------------
procedure Add (L : in out Objet; Item : Element) is
begin
if not Found (L, Item) then
L := Liste.Make (Item, L);
end if;
end Add;
---------------------------------------------------------------
--|
--| Renvoie la valeur de l'element courant dans la liste.
--|
--| Parametres d'entree :
--| Iter : iterateur sur la liste consultee
--| (type iterateur)
--| Parametres de sortie :
--| La fonction renvoie l'element
--| (type element)
--|
---------------------------------------------------------------
function Consult (Iter : Iterateur) return Element is
begin
return Liste.Value (Iter);
end Consult;
---------------------------------------------------------------
--|
--| Test si la liste est vide.
--|
--| Parametres d'entree :
--| L : liste sur laquelle porte le test
--| (type objet)
--| Parametres de sortie :
--| La fonction renvoie TRUE ou FALSE selon que la liste est
--| vide ou non
--|
---------------------------------------------------------------
function Is_Empty (L : Objet) return Boolean is
begin
return Liste.Is_Empty (L);
end Is_Empty;
---------------------------------------------------------------
--|
--| Test si un iterateur a bien survole tous les elements de
--| la liste.
--|
--| Parametres d'entree :
--| Iter : iterateur sur la liste testee
--| (type iterateur)
--| Parametres de sortie :
--| La fonction renvoie TRUE ou FALSE selon que l'iterateur
--| a bien survole toute la liste ou non
--|
---------------------------------------------------------------
function At_End (Iter : Iterateur) return Boolean is
begin
return Liste.Done (Iter);
end At_End;
---------------------------------------------------------------
--|
--| Positionne un iterateur sur le premier element d'une liste.
--|
--| Parametres d'entree :
--| Iter : l'iterateur de la liste
--| (type iterateur)
--| L : liste a iterer
--| (type objet)
--|
---------------------------------------------------------------
procedure First (Iter : out Iterateur; L : Objet) is
begin
Liste.Init (Iter, L);
end First;
---------------------------------------------------------------
--|
--| Positionne un iterateur sur l'element suivant d'une liste.
--|
--| Parametres d'entree :
--| Iter : l'iterateur de la liste
--| (type iterateur)
--|
---------------------------------------------------------------
procedure Next (Iter : in out Iterateur) is
begin
Liste.Next (Iter);
end Next;
---------------------------------------------------------------
--|
--| Supprime un element de la liste si ce dernier s'y trouve.
--| Si ce n'est pas le cas cette routine n'a aucun effet.
--|
--| Parametres d'entree :
--| L : liste sur laquelle porte la suppression
--| (type objet)
--| Item : element a supprimer de la liste
--| (type element)
--|
---------------------------------------------------------------
procedure Delete (L : in out Objet; Item : Element) is
Local_List_Iterateur, L_Iterateur : Liste.Iterator;
Local_List : Objet;
begin
if Found (L, Item) then
Liste.Init (L_Iterateur, L);
while (not Equal (Item, Liste.Value (L_Iterateur))) loop
Local_List := Liste.Make
(Liste.Value (L_Iterateur), Local_List);
L := Liste.Rest (L);
Liste.Init (L_Iterateur, L);
end loop;
L := Liste.Rest (L);
Liste.Init (L_Iterateur, L);
Liste.Init (Local_List_Iterateur, Local_List);
while not Liste.Is_Empty (Local_List) loop
L := Liste.Make (Liste.Value (Local_List_Iterateur), L);
Liste.Init (Local_List_Iterateur, Local_List);
Local_List := Liste.Rest (Local_List);
Liste.Init (Local_List_Iterateur, Local_List);
end loop;
end if;
end Delete;
---------------------------------------------------------------
--|
--| Cherche un element dans une liste.
--|
--| Parametres d'entree :
--| L : liste sur laquelle porte la recherche
--| (type objet)
--| Item : element a rechercher dans la liste
--| (type element)
--| Parametres de sortie :
--| La fonction renvoie TRUE ou FALSE selon que l'iterateur
--| a atteint la fin de la liste ou non
--|
---------------------------------------------------------------
function Found (L : Objet; Item : Element) return Boolean is
Trouve : Boolean := False;
Iterateur : Liste.Iterator;
begin
Liste.Init (Iterateur, L);
while not Liste.Done (Iterateur) loop
if Equal (Item, Liste.Value (Iterateur)) then
Trouve := True;
exit;
end if;
Liste.Next (Iterateur);
end loop;
return Trouve;
end Found;
---------------------------------------------------------------
--|
--| Initialise une liste (l'a vide).
--|
--| Parametres d'entree :
--| L : liste a initialiser
--| (type objet)
--|
---------------------------------------------------------------
procedure Free (L : in out Objet) is
begin
Liste.Free (L);
end Free;
---------------------------------------------------------------
--|
--| Compare deux listes entre elles.
--|
--| Parametres d'entree :
--| L1,L2 : les deux listes sur lesquelles porte la
--| comparaison (type objet)
--| Parametres de sortie :
--| La fonction renvoie TRUE ou FALSE selon que les deux
--| listes sont identiques ou non.
--|
---------------------------------------------------------------
function Compare (L1, L2 : Objet) return Boolean is
Idem : Boolean;
Iterateur_L1 : Liste.Iterator;
begin
if (Liste.Length (L1) = Liste.Length (L2)) then
Idem := True;
Liste.Init (Iterateur_L1, L1);
while (Idem and (not Liste.Done (Iterateur_L1))) loop
Idem := Found (L2, Liste.Value (Iterateur_L1));
Liste.Next (Iterateur_L1);
end loop;
else
Idem := False;
end if;
return Idem;
end Compare;
end Nos_Listes;
nblk1=a
nid=8
hdr6=10
[0x00] rec0=1f rec1=00 rec2=01 rec3=012
[0x01] rec0=1f rec1=00 rec2=02 rec3=014
[0x02] rec0=1c rec1=00 rec2=05 rec3=064
[0x03] rec0=1b rec1=00 rec2=09 rec3=05a
[0x04] rec0=18 rec1=00 rec2=06 rec3=06a
[0x05] rec0=1d rec1=00 rec2=04 rec3=026
[0x06] rec0=1d rec1=00 rec2=03 rec3=012
[0x07] rec0=0f rec1=00 rec2=07 rec3=000
[0x08] rec0=28 rec1=36 rec2=00 rec3=005
[0x09] rec0=fd rec1=0c rec2=4c rec3=4d5
tail 0x215429b30864d6c5e63e1 0x42a00088462060003
Free Block Chain:
0x8: 0000 00 0a 00 49 80 0d 74 79 70 65 20 65 6c 65 6d 65 ┆ I type eleme┆
0xa: 0000 00 00 00 47 80 25 20 28 49 74 65 72 20 3a 20 6f ┆ G % (Iter : o┆