====================================================================== Dokumentation zu "" Version 1.0 Autor: Nicolas Benezan, Postwiesenstr. 2, D7000 Stuttgart 60 ====================================================================== Kopierrecht ­­­­­­­­­­­ Das komplette Packet (Quelltext, Dokumentation und Objectcode) ist Public-Domain-Software. Es darf beliebig kopiert und verbreitet werden solange... * mein Name und dieser Kopierrechtshinweis erhalten bleiben, * die Vollständigkeit des ganzen Packets gewährleistet ist, und * mit dem Vertrieb dieser Software kein Gewinn erwirtschaftet wird. Die Kommerzielle Nutzung ohne meine ausdrückliche schriftliche Genehmigung ist untersagt. Falls Sie dies beabsichtigen, nehmen Sie bitte unter oben genannter Adresse Kontakt mit mir auf. Verbesserungsvorschläge sind stets willkommen. Falls Sie Veränderungen am Programm vornehmen, dokumentieren Sie diese bitte gut verständlich. Es würde mich freuen, wenn Sie mich über größere Veränderungen in Kenntnis setzen würden. (c) 1988 by Nicolas Benezan. Alle Rechte vorbehalten. Übersicht ­­­­­­­­­ * Umfang des Packets * Einleitung * Generische Datentypen * Der neue Datentyp "Row" * Beschreibung der Prozeduren * Testmodul Umfang des Packet ­­­­­­­­­­­­­­­­­ Das komplette Packet "Rows" beinhaltet folgendes: * Rows.dok Diese Dokumentation * Rows.doc Englische Dokumentation * Rows.def Definitionsmodul * Rows.mod Implementationsmodul * Rows.sym Symboldatei (compiliertes Definitionsodul) * Rows.obj Objektcode (compiliertes Implementationsmodul) * RowDemo.mod Testmodul * RowDemo.obj Compiliertes Testmodul * RowDemo Ausführbares Testmodul Einleitung ­­­­­­­­­­ Modula-II bietet einige wenige grundlegende Datenstrukturen und die Möglichkeit umfangreichere Strukturen zu konstruieren. Es unterstützt auch die Entwicklung generischer Datentypen. Das beste Beispiel hierfür ist der Typ "File", der nicht wie in Pascal zum Sprachumfang gehört, sondern aus dem Modul "FileSystem" importiert wird. Die auf diesen Typ ausführbaren Operationen werden in dem gleichen Modul angeboten. Das einzige, was der Kunde dieses Moduls wissen braucht, ist das abstrakte Konzept von Files. Dieses Modul stellt den generischen Datentyp "Row" zur Verfügung. Generischie Datentypen ­­­­­­­­­­­­­­­­­­­­­­ In Modula-II (wie auch in den meisten anderen sog. Hochsprachen) kann man neue Typen durch Deklaration erstellen. Ein neuer Typ besteht aus einer Zusammensetzung von Komponenttypen. Der Nachteil der Typendeklaration ist, daß die Komponenttypen bei der Compilation schon eindeutig definiert sein müssen (entweder handelt es sich um einen fundamentalen Type (z.B. BOOLEAN) oder einen durch Deklaration bekannten Typ). Modula-II bietet vier Strukturierungsarten zum Erstellen neuer Typen: ARRAY, SET, RECORD und POINTER. Der letztere bietet die Vorteile der dynamischen Speicherverwaltung. Mit ihm kann man die unterschiedlichsten Typen definierten. Zum Beispiel eine Liste: TYPE listptr = POINTER TO list; list = RECORD item : T0; next : listptr END; Um diese Liste sinnvoll zu benützen, entwickelt man entsprechende Prozeduren: Einfügen eines Elementes, Lesen eines Elementes usw. Die Prozeduren sind im eigentlichen Sinne unabhängig vom Komponententyp T0, aber der definierte Typ "list" hängt durch die Deklaration vom Typ T0 ab. Ein generischer Datentyp kann mit beliebigen Komponententypen arbeiten! Modula-II unterstützt die Entwicklung von Modulen (sog. Datenkapseln), die einen generischen datentyp und die auf ihn ausführbaren Operationen exportiert. Die Unterstützung ist jedoch nicht vollkommen. Die Typenprüfung von Modula-2 muß umgangen werden. Es kann lediglich die Länge der Parameter geprüft werden. Ein Parameter darf gleichlang oder kürzer (Stringkonstanten) als bei Dim() deklariert sein. Der neue Datentyp "Row" ­­­­­­­­­­­­­­­­­­­­­­­ "Rows" (deutsch: Reihen/Folgen) sind eine Art ARRAYs, jedoch mit dem Unterschied, daß die Elementanzahl nicht vor dem Compilieren sondern erst zur Laufzeit bekannt sein muß. Man kann also im laufenden Programm (wie in Basic, übrigens) die Länge einer Row mit Dim() festlegen. Rows sind jedoch nicht dynamisch, wie etwa dynamische Listen. Einmal dimensioniert, darf die Länge nicht mehr verändert werden, man kann also nich wie bei Listen Elemente einfügen oder entfernen. Man hat jedoch über einen Index (wie bei ARRAYs) direkten Zugriff auf jedes beliebige Element und muß die Elemente nicht wie bei Listen der Reihe nach durchgehen. Daraus resultiert ein Zeitvorteil, wenn man oft zwischen Teilen der Daten hin und her springen muß. Beschreibung der Prozeduren ­­­­­­­­­­­­­­­­­­­­­­­­­­­ Es folgt eine Auflistung der auf den Typ "Row" möglichen Operationen: (genauere Informationen im Definitionsmodul) * Dim() erzeugt und initialisiert eine "Row" zur weiteren Benutzung. Dim() muß vor irgend einer anderen Operation aufgerufen werden. * Discard() löscht eine Row mitsamt allen Elementen und gibt den verwendeten Speicher frei. * Write() kopiert Daten von einer Variable (oder Konstante) in eine Row an der indizierten Stelle. * Read() kopiert Daten aus einer indizierten Stelle einer Row in eine Variable. * High() und CompSize() Diese Funktionen sind nützlich, wenn Rows als eine Art offene Feldparameter in Prozeduren verwendet werden, und Länge und Komponentengröße vorher nicht bekannt sind. Ähnlich wie HIGH() für ARRAYs gibt High() den maximalen Index einer Row und CompSize() die Länge deren Komponenten zurück. * Import() und Export() Diese Prozeduren können dazu benutzt werden, Rows auf (Disketten-) Files zu schreiben oder von solchen zu lesen. Sie stellen eine Schnittstelle zum Datenpuffer der Rows im Speicher zur Verfügung. Es ist jedoch äußerste Vorsicht geboten! Die Verantwortung für die Längen- und Typenkompatiblität liegt beim Anwender von Import() und Export()! Über die Parameter der Prozeduren und deren Bedeutung gibt das Definitionsmodul Auskunft. TestModul ­­­­­­­­­ Das Modul "RowDemo" testet und demonstriert Rows und ihre Benutzung. Es Dim()ensioniert eine Row mit zufälliger Elementzahl, füllt sie mit Zufallszahlen und sortiert diese dann. Als Sortieralgorithmus wurde "Heapsort" gewählt, in dem nur die ":="-Zuweisungen durch Read()/Write() Befehle ersetzt wurden. Wenn Sie die Speicheranzeige der Workbench betrachten, während RowDemo läuft, sehen Sie, daß die Rows je nach ihrer Länge mehr oder weniger Speicher verbrauchen. (Für die Zyklenknauserer: Ja, ich weiß selbst, daß man den Heapsort noch opimieren könnte. Aber dies soll schließlich keine Geschwindig- keitsdemo sein.)