|##########| |#MAGIC #|CLABLLAK |#PROJECT #|"ImportAll" |#PATHS #|"StdProject" |#FLAGS #|xx---x-xx---xxx----------------- |#USERSW #|-------------------------------- |#USERMASK#|-------------------------------- |#SWITCHES#|xx---xxxxx------ |##########| DEFINITION MODULE Lists; FROM FileSystem IMPORT File; FROM Resources IMPORT ContextPtr; EXCEPTION | | FileTypeMismatch : Durch Load, wenn versucht wird eine Liste aus einem | File zu laden, in dem keine abgespeichert war. | FileTypeMismatch : "File type and current type don't match"; | | ListEmpty : Falls versucht wurd ein Element aus einer leeren | Liste zu entfernen | ListEmpty : "List is allready empty"; DEFINITION MODULE BiLists(BiNodePtr : POINTER TO BiNode); | | BiLists: | | Doppelt verkettete Liste, alle Elemente der Liste müssen Nachfolger | des Typs "BiNode" sein. | | Typen: | | BiList: | .first : Zeiger auf ersten Knoten der Liste, NIL, wenn die Liste | leer ist. | .last : Zeiger auf letzten Knoten der Liste, NIL, wenn die Liste | leer ist. | | BiNode: | .next : Zeiger auf nächsten Knoten der Liste, NIL, wenn es selbst | der letzte Knoten ist. | .prev : Zeiger auf vorherigen Knoten der Liste, NIL, wenn es selbst | der erste Knoten ist. | | Methoden: | | Init : Initialisiert die Liste, muß geschehen, bevor das erste | Element in die Liste eingefügt wird. | | InsertTop : Fügt einen Knoten am Anfang der Liste ein. | InsertBottom : Fügt einen Knoten am Ende der Liste ein. | InsertAfter : Fügt einen Knoten direkt nach einem bereits in der Liste | vorhandenen ein. | InsertBefore : Fügt einen Knoten direkt voe einem bereits in der Liste | vorhandenen ein. | | RemoveFirst : Entfernt das erste Element aus der Liste, und gibt dieses | zurück. | RemoveLast : Entfernt das letzte Element aus der Liste, und gibt dieses | zurück. | Remove : Entfernt ein übergebenes Element aus der Liste. | Remove_IF : Entfernt alle Elemente aus der Liste, für die eine | Bedingung erfüllt ist. | Remove_All : Entfernt alle Elemente aus der Liste. | | Delete.. : Wie Remove.., nur werden die Elemente durch Dispose | freigegeben. | Destruct.. : Wie Remove.., nur wird für alle Methoden die Destructor | Prozedur aufgerufen. | | Apply : Für jedes Element der Liste wird eine übergebene Prozedur | aufgerufen. | Sort : Die Liste wird anhand einer Ordnungsrelation sortiert. | n_th : Liefert das n-te Element der Liste | isEmpty : Liefert TRUE, wenn die Liste leer ist. | Find : Liefert das erste Element, für das eine Bedingung erfüllt | dies. | FindNext : Liefert das nächste Element, für das eine Bedingung | erfüllt ist. | | Append : Fügt eine Liste an eine andere an, die angehängte Liste | enthält danach keine Elemente mehr. | | Save : Sichert eine Liste in eine File. | Load : Lädt eine Liste aus einem File. | | TYPE BiNode = RECORD prev, next : BiNodePtr; END; BiList = RECORD first, last : BiNodePtr END; ApplyProc = PROCEDURE(n : BiNodePtr); Destructor = PROCEDURE(n : BiNodePtr); Relation = PROCEDURE(a,b : BiNodePtr):BOOLEAN; Check = PROCEDURE(n : BiNodePtr):BOOLEAN; SaveProc = PROCEDURE(f : File;data : BiNodePtr); LoadProc = PROCEDURE(f : File):BiNodePtr; | | l -> zu initialisierende Liste | PROCEDURE Init(VAR l : BiList); | | l <> Liste in die eingehängt wird | n <- Knoten, der eingehängt wird | PROCEDURE InsertTop(VAR l : BiList;n : BiNodePtr); | | l <> Liste in die eingehängt wird | n <- Knoten, der eingehängt wird | PROCEDURE InsertBottom(VAR l : BiList;n : BiNodePtr); | | l <> Liste in die eingehängt wird | n <- Knoten, der eingehängt wird | pred <- Knoten, nach dem eingehängt wird | PROCEDURE InsertAfter(VAR l : BiList;pred,n : BiNodePtr); | | l <> Liste in die eingehängt wird | n <- Knoten, der eingehängt wird | succ <- Knoten, vor dem eingehängt wird | PROCEDURE InsertBefore(VAR l : BiList;succ,n : BiNodePtr); | | l <> Liste aus der ausgehängt wird | -> Knoten, der ausgehängt wurde | PROCEDURE RemoveFirst(VAR l : BiList):BiNodePtr; | | l <> Liste aus der ausgehängt wird | -> Knoten, der ausgehängt wurde | PROCEDURE RemoveLast(VAR l : BiList):BiNodePtr; | | l <> Liste aus der ausgehängt wird | n <- Knoten, der ausgehängt wird | PROCEDURE Remove(VAR l : BiList;n : BiNodePtr); | | l <> Liste aus der ausgehängt wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten ausgehängt | wird | PROCEDURE Remove_IF(VAR l : BiList;if : Check); | | l <> Liste aus der alle Elemente ausgehängt werden | PROCEDURE Remove_All(VAR l : BiList); | | l <> Liste aus der freigegeben wird | PROCEDURE DeleteFirst(VAR l : BiList); | | l <> Liste aus der freigegeben wird | PROCEDURE DeleteLast(VAR l : BiList); | | l <> Liste aus der freigegeben wird | n <- Knoten der freigeben werden soll | PROCEDURE Delete(VAR l : BiList;n : BiNodePtr); | | l <> Liste aus der freigegeben wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten freigegeben | wird. | PROCEDURE Delete_IF(VAR l : BiList;if : Check); | | l <> Liste aus der alle Elemente freigegeben werden | PROCEDURE Delete_All(VAR l : BiList); | | l <> Liste aus der vernichtet wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten freigegeben | wird. | des <- Routine, die den übergebenen Knoten vernichten sollte. | PROCEDURE Destruct_IF(VAR l : BiList;if : Check;des : Destructor); | | l <> Liste aus der alle Elemente vernichtet werden | des <- Routine, die den übergebenen Knoten vernichten sollte. | PROCEDURE Destruct_All(VAR l : BiList;des : Destructor); | | l <> Liste, deren Elemente bearbeitet werden | proc <- Routine, die für jedes Element aufgerufen wird | PROCEDURE Apply(VAR l : BiList;proc : ApplyProc); | | l <> Liste, deren Elemente sortiert werden | greater<- Ordnungsrelation, nach der die Liste sortiert wird | PROCEDURE Sort(VAR l : BiList;greater : Relation); | | l <- Liste, in der Element gesucht wird | n <- Nummer des zu findenden Elements | -> Zeiger auf n-ten Knoten oder NIL, wenn die Liste weniger | Elemente enthält. | PROCEDURE n_th(VAR l : BiList;n : INTEGER):BiNodePtr; | | l <- Liste, deren Elemente gezählt werden soll | -> Anzahl der Elemente | PROCEDURE Count(VAR l : BiList ): INTEGER; | | l <- Liste, die geprüft werden soll | -> TRUE, wenn die Liste leer ist | PROCEDURE isEmpty(VAR l : BiList):BOOLEAN; | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | -> Erster Knoten, für den die Bedingung zutrifft, oder NIL, falls | die Bedingung für kein Element zutrifft. | PROCEDURE Find(VAR l : BiList;equal : Check):BiNodePtr; | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | start <- Element, ab dessen Nachfolger gesucht wird | -> Nächster Knoten, für den die Bedingung zutrifft, oder NIL, | falls die Bedingung für kein weiteres Element zutrifft. | PROCEDURE FindNext(VAR l : BiList;equal : Check;start : BiNodePtr):BiNodePtr; | | dest <> Liste, an die angehängt wird, enthält nach der Prozedur die | Elemente beider Listen. | arg <> Liste, die angehängt wird, enthält nach der Prozedur keine | Elemente mehr. | PROCEDURE Append(VAR dest,arg : BiList); | | l <- Liste, die gesichert wird | f <- File, in das geschrieben wird | part <- Routine, die ein Listenelement in das File schreibt, wird | nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Save(VAR l : BiList;f : File;part : SaveProc); | | l <- Liste, in die geladen wird | f <- File, aus dem gelesen wird. | part <- Routine, die ein Listenelement erzeugt und aus dem File liest, | wird nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Load(VAR l : BiList;f : File;part : LoadProc); END BiLists; DEFINITION MODULE SingleLists(NodePtr : POINTER TO Node); | | SingleLists: | | Einfach verkettete Liste, alle Elemente der Liste müssen Nachfolger | des Typs "Node" sein. | | Typen: | | List: | .first : Zeiger auf ersten Knoten der Liste, NIL, wenn die Liste | leer ist. | .last : Zeiger auf letzten Knoten der Liste, NIL, wenn die Liste | leer ist. | | Node: | .next : Zeiger auf nächsten Knoten der Liste, NIL, wenn es selbst | der letzte Knoten ist. | | Methoden: | | Init : Initialisiert die Liste, muß geschehen, bevor das erste | Element in die Liste eingefügt wird. | | InsertTop : Fügt einen Knoten am Anfang der Liste ein. | InsertBottom : Fügt einen Knoten am Ende der Liste ein. | InsertAfter : Fügt einen Knoten direkt nach einem bereits in der Liste | vorhandenen ein. | | RemoveFirst : Entfernt das erste Element aus der Liste, und gibt dieses | zurück. | Remove : Entfernt ein übergebenes Element aus der Liste. | Remove_IF : Entfernt alle Elemente aus der Liste, für die eine | Bedingung erfüllt ist. | Remove_All : Entfernt alle Elemente aus der Liste. | | Delete.. : Wie Remove.., nur werden die Elemente durch Dispose | freigegeben. | Destruct.. : Wie Remove.., nur wird für alle Methoden die Destructor | Prozedur aufgerufen. | | Apply : Für jedes Element der Liste wird eine übergebene Prozedur | aufgerufen. | Sort : Die Liste wird anhand einer Ordnungsrelation sortiert. | n_th : Liefert das n-te Element der Liste | isEmpty : Liefert TRUE, wenn die Liste leer ist. | Find : Liefert das erste Element, für das eine Bedingung erfüllt | dies. | FindNext : Liefert das nächste Element, für das eine Bedingung | erfüllt ist. | | Append : Fügt eine Liste an eine andere an, die angehängte Liste | enthält danach keine Elemente mehr. | | Save : Sichert eine Liste in eine File. | Load : Lädt eine Liste aus einem File. | | TYPE Node = RECORD next : NodePtr END; List = RECORD first, last : NodePtr END; ApplyProc = PROCEDURE(n : NodePtr); Destructor = PROCEDURE(n : NodePtr); Relation = PROCEDURE(a,b : NodePtr):BOOLEAN; Check = PROCEDURE(n : NodePtr):BOOLEAN; SaveProc = PROCEDURE(f : File;data : NodePtr); LoadProc = PROCEDURE(f : File):NodePtr; | | l -> zu initialisierende Liste | PROCEDURE Init(VAR l : List); | | l <> Liste, in die eingehängt wird | n <- Knoten, der eingehängt wird | PROCEDURE InsertTop(VAR l : List;n : NodePtr); | | l <> Liste, in die eingehängt wird | n <- Knoten, der eingehängt wird | PROCEDURE InsertBottom(VAR l : List;n : NodePtr); | | l <> Liste, in die eingehängt wird | pred <- Knoten, nachdem eingehängt wird | n <- Knoten, der eingehängt wird | PROCEDURE InsertAfter(VAR l : List;pred,n : NodePtr); | | l <> Liste aus der ausgehängt wird | -> Knoten, der ausgehängt wurde | PROCEDURE RemoveFirst(VAR l : List):NodePtr; | | l <> Liste aus der ausgehängt wird | n <- Knoten, der ausgehängt wird | PROCEDURE Remove(VAR l : List;n : NodePtr); | | l <> Liste aus der ausgehängt wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten ausgehängt | wird | PROCEDURE Remove_IF(VAR l : List;if : Check); | | l <> Liste aus der alle Elemente ausgehängt werden | PROCEDURE Remove_All(VAR l : List); | | l <> Liste aus der freigegeben wird | PROCEDURE DeleteFirst(VAR l : List); | | l <> Liste aus der freigegeben wird | n <- Knoten der freigeben werden soll | PROCEDURE Delete(VAR l : List;n : NodePtr); | | l <> Liste aus der freigegeben wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten freigegeben | wird. | PROCEDURE Delete_IF(VAR l : List;if : Check); | | l <> Liste aus der alle Elemente freigegeben werden | PROCEDURE Delete_All(VAR l : List); | | l <> Liste aus der vernichtet wird | if <- Bedingung, die erfüllt sein muß, damit der Knoten freigegeben | wird. | des <- Routine, die den übergebenen Knoten vernichten sollte. | PROCEDURE Destruct_IF(VAR l : List;if : Check;des : Destructor); | | l <> Liste aus der alle Elemente vernichtet werden | des <- Routine, die den übergebenen Knoten vernichten sollte. | PROCEDURE Destruct_All(VAR l : List;des : Destructor); | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | -> Erster Knoten, für den die Bedingung zutrifft, oder NIL, falls | die Bedingung für kein Element zutrifft. | PROCEDURE Find(VAR l : List;equal : Check):NodePtr; | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | start <- Element, ab dessen Nachfolger gesucht wird | -> Nächster Knoten, für den die Bedingung zutrifft, oder NIL, | falls die Bedingung für kein weiteres Element zutrifft. | PROCEDURE FindNext(VAR l : List;equal : Check;start : NodePtr):NodePtr; | | l <> Liste, deren Elemente bearbeitet werden | proc <- Routine, die für jedes Element aufgerufen wird | PROCEDURE Apply(VAR l : List;proc : ApplyProc); | | l <> Liste, deren Elemente sortiert werden | greater<- Ordnungsrelation, nach der die Liste sortiert wird | PROCEDURE Sort(VAR l : List;greater : Relation); | | l <- Liste, in der Element gesucht wird | n <- Nummer des zu findenden Elements | -> Zeiger auf n-ten Knoten oder NIL, wenn die Liste weniger | Elemente enthält. | PROCEDURE n_th(VAR l : List;n : INTEGER):NodePtr; | | dest <> Liste, an die angehängt wird, enthält nach der Prozedur die | Elemente beider Listen. | arg <> Liste, die angehängt wird, enthält nach der Prozedur keine | Elemente mehr. | PROCEDURE Append(VAR dest,arg : List); | | l <- Liste, die gesichert wird | f <- File, in das geschrieben wird | part <- Routine, die ein Listenelement in das File schreibt, wird | nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Save(VAR l : List;f : File;part : SaveProc); | | l <- Liste, in die geladen wird | f <- File, aus dem gelesen wird. | part <- Routine, die ein Listenelement erzeugt und aus dem File liest, | wird nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Load(VAR l : List;f : File;part : LoadProc); END SingleLists; DEFINITION MODULE SortedBiLists(BiNodePtr : POINTER TO BiNode); | | SortedBiLists: | | Sortierte doppelt verkettete Listen, die meisten Funktionen | werden von BiLists ererbt. Die Elemente werden bereits beim Einfügen | an der richtigen Stelle eingefüget | | Typen: | | BiList: (siehe BiLists.BiList) | .greater : Ordnungsrelation | | Methoden | | Mix : Mischt zwei Listen zu einer neuen, wobei die Ordnung | erhalten bleibt. | EXCEPTION | | RelationMismatch : Zwei Listen wurden gemischt, die verschiedene | Ordnungsrelationen besitzen. | | RelationMismatch : "Relations in sorted lists don't match"; DEFINITION MODULE BiLists = BiLists(BiNodePtr); FROM BiLists IMPORT Remove,RemoveFirst,RemoveLast,Remove_IF,Remove_All, Delete,DeleteFirst,DeleteLast,Delete_IF,Delete_All, Destruct_IF,Destruct_All,Relation; TYPE BiNode = RECORD OF BiLists.BiNode END; BiList = RECORD OF BiLists.BiList greater : Relation END; SaveProc = PROCEDURE(f : File;data : BiNodePtr); LoadProc = PROCEDURE(f : File):BiNodePtr; | | l -> zu initialisierende Liste | greater<- Ordnungsrelation | PROCEDURE Init(VAR l : BiList;greater : Relation); | | l <> Liste in die eingefügt wird | n <- Knoten der eingefügt wird | PROCEDURE Insert(VAR l : BiList;n : BiNodePtr); | | | dest <> Zielliste, enthält danach die neue Liste | arg <> Argumentsliste, ist nach der Prozedur leer | PROCEDURE Mix(VAR dest,arg : BiList); | | l <- Liste, die gesichetr wird | f <- File, in das geschrieben wird | part <- Routine, die ein Listenelement sichert | PROCEDURE Save(VAR l : BiList;f : File;part : SaveProc); | | l -> Liste, in die geladen wird | f <- File, aus dem gelesen wird | part <- Routine, die ein Listenelement erzeugt und einliest | PROCEDURE Load(VAR l : BiList;f : File;part : LoadProc); END SortedBiLists; DEFINITION MODULE TextLists(TextNodePtr : POINTER TO TextNode); | | TextLists: | | Listen sortierter Strings, zwei Vergleichsprozeduren werden bereits | vorgegeben, wobei eine die Groß/Kleinschreibung nicht berücksichtigt. | Das Modul setzt völlig auf SortedBiLists auf. | DEFINITION MODULE TL = SortedBiLists(TextNodePtr); TYPE TextList = TL.BiList; TextNode = RECORD OF TL.BiNode name : CLASSPTR TO STRING; special : BOOLEAN; END; PROCEDURE CmpStrings(a,b : TextNodePtr):BOOLEAN; PROCEDURE CmpStringsCaps(a,b : TextNodePtr):BOOLEAN; END TextLists; DEFINITION MODULE CursorLists(type : ANYPTR); | | CursorLists: | | Listen, in denen die Elemente nicht direkt miteinander verkettet sind, | sondern, durch Zeiger einer anderen Liste erreicht werden. Eine Cursor- | list ist eine doppelt verkettete Liste, von Knoten, die jeweils einen | Zeiger auf ein Element der Liste enthalten. Der Vorteil ist, daß in einer | derartigen Liste beliebige Elemente verwendet werden können (also nicht | nur Nachfolger eines Knotentyps) und ein Element auch in mehreren Listen | erscheinen kann. Der Nachteil ist, daß man kaum vom Listenelement auf | den zugehörigen Knoten schliessen kann, was Listenoperationen erschwert. | Die Lösung des Problems besteht darin, daß die Liste einen Cursor | enthält, der auf den Knoten des aktiven Elements zeigt. Listenoperationen | werden immer relativ zu diesm Cursor vorgenommen, der mit Hilfe mehrerer | Prozeduren verschoben werden kann. | | Typen: | | List: (siehe auch BiLists.BiList) | .mark : Hilfsmarke, für Cursoroperationen | .cursor : Zeiger auf Knoten des aktiven Elements | | PtrNode: (siehe auch BiLists.BiList) | .data : Zeiger auf Element der Liste | | Methoden: | | Init : Initialisiert die Liste, muß ausgeführt werden, bevor | die Liste verwendet werden kann. | | Get : Liefert das aktuelle Listenelement (nicht den Knoten) | | InsertTop : Fügt ein Element als erstes in die Liste ein | InsertBottom: Fügt ein Element als letztes in die Liste ein | InsertBefore: Fügt ein Element vor dem Cursor ein | InsertAfter : Fügt ein Element nach dem Cursor ein | | RemoveFirst : Entfernt das erste Element aus der Liste, läßt dieses | aber unberührt | RemoveLast : Entfernt das letzte Element aus der Liste, läßt dieses | aber unberührt | RemoveAct : Entfernt das aktuelle Element aus der Liste | Remove : Entfernt ein angegebenes Element aus der Liste, diese | Routinen benötigt mehr Zeit als die anderen, da es den | Knoten des Elements erst suchen muß. | Remove_IF : Entfernt alle Elemente aus der Liste, für die eine | Bedingung erfüllt ist. | Remove_All : Entfernt alle Elemente aus der Liste. | | Delete.. : Wie Remove.., nur wird das Element selbst durch Dispose | vernichtet. | Destruct.. : Wie Remove.., nur werden die Elemente durch eine | Destructor Prozedur vernichtet | | Apply : Für jedes Element der Liste wird eine übergebene Prozedur | aufgerufen. | Sort : Sortiert die Liste anhand einer Ordnungsrelation | Append : Hängt eine Liste an eine andere an. | Dup : Erzeugt eine Kopie einer Liste. | | Find : Sucht das erste Element in einer Liste, für die eine | angegebene Bedingung erfüllt ist. | FindNext : Sucht das nächste Element, für das eine Bedingung | erfüllt ist. | | Mark : Markiert den aktuellen Knoten | GoMark : Setzt den Cursor auf den zuletzt markierten Knoten. | | Next : Bewegt den Cursor ein Element weiter | Prev : Bewegt den Cursor ein Element zurück | First : Setzt den Cursor auf das erste Element der Liste | Last : Setzt den Cursor auf das letzte Element der Liste | n_th : Setzt den Cursor auf das n-te Element der Liste | Go : Bewegt den Cursor auf ein angegebenes Element | HasCursor : Liefert TRUE, wenn der Cursor auf ein Element der Liste | zeigt. | | Save : Sichert eine Liste in ein File | Load : Liest eine Liste aus einem File | EXCEPTION | | NoCursor : Der Cursor zeigt auf kein Element der Liste. | NoCursor : "No cursor set"; | | NotFound : Das gewünschte Element ist nicht in der Liste | enthalten | NotFound : "Entry not found"; TYPE PtrNodePtr = POINTER TO PtrNode; DEFINITION MODULE CList = BiLists(PtrNodePtr); TYPE PtrNode = RECORD OF CList.BiNode data : type END; List = RECORD OF CList.BiList mark, cursor : PtrNodePtr; END; ApplyProc = PROCEDURE(n : type); Destructor = PROCEDURE(n : type); Relation = PROCEDURE(a,b : type):BOOLEAN; Check = PROCEDURE(n : type):BOOLEAN; SaveProc = PROCEDURE(f : File;data : type); LoadProc = PROCEDURE(f : File):type; | | l -> zu initialisierende Liste | PROCEDURE Init(VAR l : List); | | l <- Liste aus der das Element zu holen ist | -> akutelles Element | PROCEDURE Get(VAR l : List):type; | | l <> Liste, in die eingefügt wird | t <- Element, das eingefügt wird | PROCEDURE InsertTop(VAR l : List;t : type); | | l <> Liste, in die eingefügt wird | t <- Element, das eingefügt wird | PROCEDURE InsertBottom(VAR l : List;t : type); | | l <> Liste, in die eingefügt wird | t <- Element, das eingefügt wird | PROCEDURE InsertBefore(VAR l : List;t : type); | | l <> Liste, in die eingefügt wird | t <- Element, das eingefügt wird | PROCEDURE InsertAfter(VAR l : List;t : type); | | l <> Liste, aus der entfernt wird | -> Element, das entfernt wurde | PROCEDURE RemoveFirst(VAR l : List):type; | | l <> Liste, aus der entfernt wird | -> Element, das entfernt wurde | PROCEDURE RemoveLast(VAR l : List):type; | | l <> Liste, aus der entfernt wird | -> Element, das entfernt wurde | PROCEDURE RemoveAct(VAR l : List):type; | | l <> Liste, aus der entfernt wird | t <- Element, das entfernt werden soll | PROCEDURE Remove(VAR l : List;t : type); | | l <> Liste, aus der entfernt wird | if <- Bedingung, die erfüllt sein muß, damit ein Element entfernt | wird | PROCEDURE Remove_IF(VAR l : List;if : Check); | | l <> Liste, aus der alle Elemente entfernt werden | PROCEDURE Remove_All(VAR l : List); | | l <> Liste, aus der gelöscht wird | PROCEDURE DeleteFirst(VAR l : List); | | l <> Liste, aus der gelöscht wird | PROCEDURE DeleteLast(VAR l : List); | | l <> Liste, aus der gelöscht wird | t <- Element, das gelöscht wird | PROCEDURE Delete(VAR l : List;t : type); | | l <> Liste, aus der gelöscht wird | PROCEDURE DeleteAct(VAR l : List); | | l <> Liste, aus der gelöscht wird | if <- Bedingung die erfüllt sein muß, damit ein Element gelöscht | wird. | PROCEDURE Delete_IF(VAR l : List;if : Check); | | l <> Liste, aus der alle Elemente gelöscht werden | PROCEDURE Delete_All(VAR l : List); | | l <> Liste, aus der gelöscht wird | if <- Bedingung die erfüllt sein muß, damit ein Element gelöscht | wird. | des <- Routine, die ein Element vernichten sollte | PROCEDURE Destruct_IF(VAR l : List;if : Check;des : Destructor); | | l <> Liste, aus der alle Elemente gelöscht werden | des <- Routine, die ein Element vernichten sollte | PROCEDURE Destruct_All(VAR l : List;des : Destructor); | | l <> Liste, auf die eine Routine anzuwenden ist | proc <- Prozedur die anzuwenden ist. | PROCEDURE Apply(VAR l : List;proc : ApplyProc); | | l <> Liste, die sortiert wird | greater<- Ordnungsrelation, anhand der sortiert wird | PROCEDURE Sort(VAR l : List;greater : Relation); | | dest <> Zielliste, die nach der Routine die Elemente beider Listen | enthält | arg <> Liste, deren Elemente anghängt werden. Die Liste ist danach | leer. | PROCEDURE Append(VAR dest,arg : List); | | dest -> Zielliste, die danach ein genaues Abbild der Quelliste bildet | arg <- Quelliste, die nicht verändert wird | PROCEDURE Dup(VAR dest,arg : List); | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | -> Erster Knoten, für den die Bedingung zutrifft, oder NIL, falls | die Bedingung für kein Element zutrifft. | PROCEDURE Find(VAR l : List;equal : Check); | | l <- Liste, in der gesucht wird | equal <- Bedingung, nach der gesucht wird | -> Nächster Knoten, für den die Bedingung zutrifft, oder NIL, | falls die Bedingung für kein weiteres Element zutrifft. | PROCEDURE FindNext(VAR l : List;equal : Check); | | l <> Liste, in der die Marke gesetzt wird | PROCEDURE Mark(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | PROCEDURE GoMark(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | PROCEDURE Next(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | PROCEDURE Prev(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | PROCEDURE First(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | PROCEDURE Last(VAR l : List); | | l <> Liste, in der der Cursor bewegt wird | n <- Nummer des Elements auf das der Cursor gesetzt wird | PROCEDURE n_th(VAR l : List; n : INTEGER); | | l <> Liste, in der der Cursor bewegt wird | t <- Element, auf dessen Knoten der Cursor gestzt wird | PROCEDURE Go(VAR l : List;t : type); | | l <- Liste, die getestet wird | -> TRUE, wenn der Cursor auf ein Element der Liste zeigt | PROCEDURE HasCursor(VAR l : List):BOOLEAN; | | l <- Liste, die gesichert wird | f <- File, in das geschrieben wird | part <- Routine, die ein Listenelement in das File schreibt, wird | nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Save(VAR l : List;f : File;part : SaveProc); | | l <- Liste, in die geladen wird | f <- File, aus dem gelesen wird. | part <- Routine, die ein Listenelement erzeugt und aus dem File liest, | wird nacheinander für alle Listenelemente aufgerufen. | PROCEDURE Load(VAR l : List;f : File;part : LoadProc); | | Die Knoten der Listen werden nach Benutzung nicht sofort freigegeben, | sondern für andere Knoten weiterverwendet. Mit dieser Routine können | die Knoten, die auf Weiterverwendung warten freigegeben werden. | PROCEDURE GarbageCollect; END CursorLists; END Lists.