|
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: 26624 (0x6800)
Types: Ada Source
Notes: 03_class, FILE, R1k_Segment, e3_tag, generic, package Lists, seg_049026, seg_049374
└─⟦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⟧
generic
type Itemtype is private; --| This is the data being manipulated.
with function Equal (X, Y : in Itemtype) return Boolean is "=";
--| This allows the user to define
--| equality on ItemType. For instance
--| if ItemType is an abstract type
--| then equality is defined in terms of
--| the abstract type. If this function
--| is not provided equality defaults to
--| =.
package Lists is
--| This package provides singly linked lists with elements of type
--| ItemType, where ItemType is specified by a generic parameter.
--| Overview
--| When this package is instantiated, it provides a linked list type for
--| lists of objects of type ItemType, which can be any desired type. A
--| complete set of operations for manipulation, and releasing
--| those lists is also provided. For instance, to make lists of strings,
--| all that is necessary is:
--|
--| type StringType is string(1..10);
--|
--| package Str_List is new Lists(StringType); use Str_List;
--|
--| L:List;
--| S:StringType;
--|
--| Then to add a string S, to the list L, all that is necessary is
--|
--| L := Create;
--| Attach(S,L);
--|
--|
--| This package provides basic list operations.
--|
--| Attach append an object to an object, an object to a list,
--| or a list to an object, or a list to a list.
--| Copy copy a list using := on elements
--| CopyDeep copy a list by copying the elements using a copy
--| operation provided by the user
--| Create Creates an empty list
--| DeleteHead removes the head of a list
--| DeleteItem delete the first occurrence of an element from a list
--| DeleteItems delete all occurrences of an element from a list
--| Destroy remove a list
--| DestroyDeep destroy a list as well as the elements in that list
--| Equal are two lists equal
--| FirstValue get the information from the first element of a list
--| Forward advances an iterator
--| IsInList determines whether a given element is in a given list
--| IsEmpty returns true if the list is empty
--| LastValue return the last value of a list
--| Length Returns the length of a list
--| MakeList this takes a single element and returns a list
--| MakeListIter prepares for an iteration over a list
--| More are there any more items in the list
--| Next get the next item in a list
--| ReplaceHead replace the information at the head of the list
--| ReplaceTail replace the tail of a list with a new list
--| Tail get the tail of a list
--| CellValue this takes an iterator and returns the value of the element
--| whose position the iterator holds
--|
--| N/A: Effects, Requires, Modifies, and Raises.
--| Notes
--| Programmer Buddy Altus
--| Types
--| -----
type List is private;
type Listiter is private;
--| Exceptions
--| ----------
Circularlist : exception; --| Raised if an attemp is made to
--| create a circular list. This
--| results when a list is attempted
--| to be attached to itself.
Emptylist : exception; --| Raised if an attemp is made to
--| manipulate an empty list.
Itemnotpresent : exception; --| Raised if an attempt is made to
--| remove an element from a list in
--| which it does not exist.
Nomore : exception; --| Raised if an attemp is made to
--| get the next element from a list
--| after iteration is complete.
--| Operations
--| ----------
----------------------------------------------------------------------------
procedure Attach ( --| appends List2 to List1
List1 : in out List; --| The list being appended to.
List2 : in List --| The list being appended.
);
--| Raises
--| CircularList
--| Effects
--| Appends List1 to List2. This makes the next field of the last element
--| of List1 refer to List2. This can possibly change the value of List1
--| if List1 is an empty list. This causes sharing of lists. Thus if
--| user Destroys List1 then List2 will be a dangling reference.
--| This procedure raises CircularList if List1 equals List2. If it is
--| necessary to Attach a list to itself first make a copy of the list and
--| attach the copy.
--| Modifies
--| Changes the next field of the last element in List1 to be List2.
-------------------------------------------------------------------------------
function Attach ( --| Creates a new list containing the two
--| Elements.
Element1 : in
Itemtype; --| This will be first element in list.
Element2 : in
Itemtype --| This will be second element in list.
) return List;
--| Effects
--| This creates a list containing the two elements in the order
--| specified.
-------------------------------------------------------------------------------
procedure Attach ( --| List L is appended with Element.
L : in out List; --| List being appended to.
Element : in
Itemtype --| This will be last element in l ist.
);
--| Effects
--| Appends Element onto the end of the list L. If L is empty then this
--| may change the value of L.
--|
--| Modifies
--| This appends List L with Element by changing the next field in List.
--------------------------------------------------------------------------------
procedure Attach ( --| Makes Element first item in list L.
Element : in
Itemtype; --| This will be the first element in list.
L : in out List --| The List which Element is being
--| prepended to.
);
--| Effects
--| This prepends list L with Element.
--|
--| Modifies
--| This modifies the list L.
--------------------------------------------------------------------------
function Attach ( --| attaches two lists
List1 : in List; --| first list
List2 : in List --| second list
) return List;
--| Raises
--| CircularList
--| Effects
--| This returns a list which is List1 attached to List2. If it is desired
--| to make List1 be the new attached list the following ada code should be
--| used.
--|
--| List1 := Attach (List1, List2);
--| This procedure raises CircularList if List1 equals List2. If it is
--| necessary to Attach a list to itself first make a copy of the list and
--| attach the copy.
-------------------------------------------------------------------------
function Attach
( --| prepends an element onto a list
Element : in Itemtype; --| element being prepended to list
L : in List --| List which element is being added
--| to
) return List;
--| Effects
--| Returns a new list which is headed by Element and followed by L.
------------------------------------------------------------------------
function Attach ( --| Adds an element to the end of a list
L : in
List; --| The list which element is being added to.
Element : in
Itemtype --| The element being added to the end of
--| the list.
) return List;
--| Effects
--| Returns a new list which is L followed by Element.
--------------------------------------------------------------------------
function Copy ( --| returns a copy of list1
L : in List --| list being copied
) return List;
--| Effects
--| Returns a copy of L.
--------------------------------------------------------------------------
generic
with function Copy (I : in Itemtype) return Itemtype;
function Copydeep ( --| returns a copy of list using a user supplied
--| copy function. This is helpful if the type
--| of a list is an abstract data type.
L : in List --| List being copied.
) return List;
--| Effects
--| This produces a new list whose elements have been duplicated using
--| the Copy function provided by the user.
------------------------------------------------------------------------------
function Create --| Returns an empty List
return List;
------------------------------------------------------------------------------
procedure Deletehead ( --| Remove the head element from a list.
L : in out
List --| The list whose head is being removed.
);
--| RAISES
--| EmptyList
--|
--| EFFECTS
--| This will return the space occupied by the first element in the list
--| to the heap. If sharing exists between lists this procedure
--| could leave a dangling reference. If L is empty EmptyList will be
--| raised.
------------------------------------------------------------------------------
procedure Deleteitem
( --| remove the first occurrence of Element
--| from L
L : in out List; --| list element is being removed from
Element : in Itemtype --| element being removed
);
--| EFFECTS
--| Removes the first element of the list equal to Element. If there is
--| not an element equal to Element than ItemNotPresent is raised.
--| MODIFIES
--| This operation is destructive, it returns the storage occupied by
--| the elements being deleted.
----------------------------------------------------------------------------
function Deleteitem
( --| remove the first occurrence of Element
--| from L
L : in List; --| list element is being removed from
Element : in Itemtype --| element being removed
) return List;
--| EFFECTS
--| This returns the List L with the first occurrence of Element removed.
------------------------------------------------------------------------------
function Deleteitems
( --| remove all occurrences of Element
--| from L.
L : in List; --| The List element is being removed from
Element : in Itemtype --| element being removed
) return List;
--| EFFECTS
--| This function returns a copy of the list L which has all elements which
--| have value Element removed.
-------------------------------------------------------------------------------
procedure Deleteitems ( --| remove all occurrences of Element
--| from L.
L : in out
List; --| The List element is being removed from
Element : in Itemtype --| element being removed
);
--| EFFECTS
--| This procedure removes all occurrences of Element from the List L. This
--| is a destructive procedure.
------------------------------------------------------------------------------
procedure Destroy ( --| removes the list
L : in out List --| the list being removed
);
--| Effects
--| This returns to the heap all the storage that a list occupies. Keep in
--| mind if there exists sharing between lists then this operation can leave
--| dangling references.
------------------------------------------------------------------------------
generic
with procedure Dispose (I : in out Itemtype);
procedure Destroydeep ( --| Destroy a list as well as all objects which
--| comprise an element of the list.
L : in out List);
--| OVERVIEW
--| This procedure is used to destroy a list and all the objects contained
--| in an element of the list. For example if L is a list of lists
--| then destroy L does not destroy the lists which are elements of L.
--| DestroyDeep will now destroy L and all the objects in the elements of L.
--| The produce Dispose is a procedure which will destroy the objects which
--| comprise an element of a list. For example if package L was a list
--| of lists then Dispose for L would be the Destroy of list type package L was
--| instantiated with.
--| REQUIRES
--| This procedure requires no sharing between elements of lists.
--| For example if L_int is a list of integers and L_of_L_int is a list
--| of lists of integers and two elements of L_of_L_int have the same value
--| then doing a DestroyDeep will cause an access violation to be raised.
--| The best way to avoid this is not to have sharing between list elements
--| or use copy functions when adding to the list of lists.
------------------------------------------------------------------------------
function Firstvalue
( --| returns the contents of the first record of the
--| list
L : in List --| the list whose first element is being
--| returned
) return Itemtype;
--| Raises
--| EmptyList
--|
--| Effects
--| This returns the Item in the first position in the list. If the list
--| is empty EmptyList is raised.
-------------------------------------------------------------------------------
procedure Forward ( --| Advances the iterator.
I : in out Listiter --| The iterator.
);
--| OVERVIEW
--| This procedure can be used in conjunction with Cell to iterate over a list.
--| This is in addition to Next. Instead of writing
--|
--| I :ListIter;
--| L :List;
--| V :List_Element_Type;
--|
--| I := MakeListIter(L);
--| while More(I) loop
--| Next (I, V);
--| Print (V);
--| end loop;
--|
--| One can write
--| I := MakeListIter(L);
--| while More (I) loop
--| Print (Cell (I));
--| Forward (I);
--| end loop;
-------------------------------------------------------------------------------
function Isempty ( --| Checks if a list is empty.
L : in List --| List being checked.
) return Boolean;
--------------------------------------------------------------------------
function Isinlist ( --| Checks if element is an element of
--| list.
L : in List; --| list being scanned for element
Element : in Itemtype --| element being searched for
) return Boolean;
--| Effects
--| Walks down the list L looking for an element whose value is Element.
------------------------------------------------------------------------------
function Lastvalue
( --| Returns the contents of the last record of
--| the list.
L : in List --| The list whose first element is being
--| returned.
) return Itemtype;
--| Raises
--| EmptyList
--|
--| Effects
--| Returns the last element in a list. If the list is empty EmptyList is
--| raised.
------------------------------------------------------------------------------
function Length ( --| count the number of elements on a list
L : in List --| list whose length is being computed
) return Integer;
------------------------------------------------------------------------------
function Makelist ( --| This takes in an element and returns a List.
E : in Itemtype) return List;
------------------------------------------------------------------------------
function Makelistiter
( --| Sets a variable to point to the head
--| of the list. This will be used to
--| prepare for iteration over a list.
L : in List --| The list being iterated over.
) return Listiter;
--| This prepares a user for iteration operation over a list. The iterater is
--| an operation which returns successive elements of the list on successive
--| calls to the iterator. There needs to be a mechanism which marks the
--| position in the list, so on successive calls to the Next operation the
--| next item in the list can be returned. This is the function of the
--| MakeListIter and the type ListIter. MakeIter just sets the Iter to the
--| the beginning of the list. On subsequent calls to Next the Iter
--| is updated with each call.
-----------------------------------------------------------------------------
function More ( --| Returns true if there are more elements in
--| the and false if there aren't any more
--| the in the list.
L : in Listiter --| List being checked for elements.
) return Boolean;
------------------------------------------------------------------------------
procedure Next ( --| This is the iterator operation. Given
--| a ListIter in the list it returns the
--| current item and updates the ListIter.
--| If ListIter is at the end of the list,
--| More returns false otherwise it
--| returns true.
Place : in out
Listiter; --| The Iter which marks the position in
--| the list.
Info : out Itemtype --| The element being returned.
);
--| The iterators subprograms MakeListIter, More, and Next should be used
--| in the following way:
--|
--| L: List;
--| Place: ListIter;
--| Info: SomeType;
--|
--|
--| Place := MakeListIter(L);
--|
--| while ( More(Place) ) loop
--| Next(Place, Info);
--| process each element of list L;
--| end loop;
----------------------------------------------------------------------------
procedure Replacehead ( --| Replace the Item at the head of the list
--| with the parameter Item.
L : in out List; --| The list being modified.
Info : in Itemtype --| The information being entered.
);
--| Raises
--| EmptyList
--| Effects
--| Replaces the information in the first element in the list. Raises
--| EmptyList if the list is empty.
------------------------------------------------------------------------------
procedure Replacetail
( --| Replace the Tail of a list
--| with a new list.
L : in out List; --| List whose Tail is replaced.
Newtail : in List --| The list which will become the
--| tail of Oldlist.
);
--| Raises
--| EmptyList
--|
--| Effects
--| Replaces the tail of a list with a new list. If the list whose tail
--| is being replaced is null EmptyList is raised.
-------------------------------------------------------------------------------
function Tail ( --| returns the tail of a list L
L : in List --| the list whose tail is being returned
) return List;
--| Raises
--| EmptyList
--|
--| Effects
--| Returns a list which is the tail of the list L. Raises EmptyList if
--| L is empty. If L only has one element then Tail returns the Empty
--| list.
------------------------------------------------------------------------------
function Cellvalue
( --| Return the value of the element where the iterator is
--| positioned.
I : in Listiter) return Itemtype;
--| OVERVIEW
--| This returns the value of the element at the position of the iterator.
--| This is used in conjunction with Forward.
--------------------------------------------------------------------------
function Equal ( --| compares list1 and list2 for equality
List1 : in List; --| first list
List2 : in List --| second list
) return Boolean;
--| Effects
--| Returns true if for all elements of List1 the corresponding element
--| of List2 has the same value. This function uses the Equal operation
--| provided by the user. If one is not provided then = is used.
------------------------------------------------------------------------------
private
type Cell;
type List is access Cell; --| pointer added by this package
--| in order to make a list
type Cell is --| Cell for the lists being created
record
Info : Itemtype;
Next : List;
end record;
type Listiter is new List; --| This prevents Lists being assigned to
--| iterators and vice versa
end Lists;
nblk1=19
nid=2
hdr6=30
[0x00] rec0=1b rec1=00 rec2=01 rec3=028
[0x01] rec0=1a rec1=00 rec2=04 rec3=024
[0x02] rec0=16 rec1=00 rec2=03 rec3=020
[0x03] rec0=18 rec1=00 rec2=19 rec3=03e
[0x04] rec0=1b rec1=00 rec2=05 rec3=05e
[0x05] rec0=18 rec1=00 rec2=06 rec3=006
[0x06] rec0=18 rec1=00 rec2=07 rec3=044
[0x07] rec0=1c rec1=00 rec2=08 rec3=00a
[0x08] rec0=1c rec1=00 rec2=09 rec3=030
[0x09] rec0=1b rec1=00 rec2=0a rec3=03a
[0x0a] rec0=19 rec1=00 rec2=0b rec3=024
[0x0b] rec0=18 rec1=00 rec2=0c rec3=036
[0x0c] rec0=18 rec1=00 rec2=0d rec3=016
[0x0d] rec0=14 rec1=00 rec2=0e rec3=042
[0x0e] rec0=19 rec1=00 rec2=0f rec3=07c
[0x0f] rec0=22 rec1=00 rec2=10 rec3=01c
[0x10] rec0=1b rec1=00 rec2=11 rec3=04e
[0x11] rec0=15 rec1=00 rec2=12 rec3=04a
[0x12] rec0=12 rec1=00 rec2=13 rec3=080
[0x13] rec0=1d rec1=00 rec2=14 rec3=008
[0x14] rec0=19 rec1=00 rec2=15 rec3=052
[0x15] rec0=1c rec1=00 rec2=16 rec3=032
[0x16] rec0=1c rec1=00 rec2=17 rec3=07e
[0x17] rec0=08 rec1=00 rec2=18 rec3=000
[0x18] rec0=00 rec1=00 rec2=00 rec3=000
tail 0x2174d523e865b3e1a58cf 0x42a00088462060003
Free Block Chain:
0x2: 0000 00 00 03 fc 80 28 20 69 73 20 6e 65 77 20 4c 69 ┆ ( is new Li┆