Modula 2-Sprache

Proseminar : Vergleichen Programmiersprache

zhao ,ning

Gliederung

Einleitung Module Typkonzepte Prozedurkonzepte, Anweisungen Exception Prozess, Multiprozess Mergesort OOM2 Literatur

Geschichte

<<Algorithms+Data Structures=Programs>>

1984 Turing Preis. 1966 Algo W,PL 360 in Amerika

Univerität Pascal 1971 in Schweiz Strukturiert

Programmierung 1976 wieder nach Amerika, in Firma Xero

x, Alto Computer zu entwerfen. 1977 in ETH um mit Lilith PC zusammenz

uarbeiten,Modula-2 1978 Modula-2 veröffentlichen EBNF(Extended BNF) , Syntax Diagramm Oberon,Oberon-2

Anwendungsgebiete

Unsiverselle Sprache Datenstrukturen, Software Engineering,Koncurrent Programmierung Wissenschaftliche Anwendung,Diskrete Simulation Bio-Informatik LifeLab (Labor für zellulare 2D Automaten) Große Projekte und Echtzeitsysteme Entwicklung großer System 1985.MicroPro Easy orientiert sich an Benutzer ,die Computer hassen

25 Seiten Beschreibung, leicht erlernbar Module werden getrennt kompiliert, dadurch weniger Fehlermöglichkeit

und leichtere Änderbarkeit Geschwindigkeit, leicht portierbar auf ein anderes Betriebssystem Fehler werden frühzeitig erkannt (vollständige Typprüfung,

Schnittstellenprüfung schon beim Kompilieren). Modula-2-Programme haben dadurch 3 Mal weniger Fehler als C-Program

me Einfache Implementierung paraleller Prozesse

Vorteile

Daten kapseln für zuverlässig Softwaresystem ADT Konzept wird unterstützt eine strenge Typbindung. Qualifizierte Zugriffe Pointer

Neuheit

Module

ProgrammModule

LokaleModule

GlobaleModule

Bibliotheks-module

Grundbibliotheks-module

BasisModule

Benutzer-module

Modulhierarchie

Module Internationaler Standard definiert 5 System Module: SYSTEM,

COROUTINES, TERMINATION, EXCEPTIONS und M2EXCEPTION. Keine Übersetzung der SYSTEM Module notwendig. Durch die Systemmodule werden bereitgestellt:

rechnerspezifischer Datentypen und Prozeduren, Typtransfer-Funktionen und die Möglichkeit der Deklaration von Variablen

mit festen Adressen.

Durch SYSTEM-Modul bereitgestellte Datentypen: WORD, ADDRESS, PROCESS.

Durch SYSTEM-Modul bereitgestellte Prozeduren: ADR, SIZE, TSIZE, NEWPROCESS, TRANSFER sowie weitere Objekte,

abhängig von verwendeten Compiler.

HELLOWORLD Qualifizierter Import MODULE hello; IMPORT InOut; BEGIN InOut.WriteString("Hello, world!");

InOut.WriteLn; END hello.

Nicht qualifizierter Import MODULE hello; FROM InOut IMPORT WriteString,

WriteLn; BEGIN WriteString("Hello, world!"); WriteLn; END hello.

Schachtelung von Modulen Lokale Module können überall definiert werden, wo auch lokale Variablen

definiert werden dürfen. Innere Module sehen nicht die Deklarationen des umschließenden Moduls Ein umschließender Modul sieht nur die exportierten Bezeichner Module auf gleicher Ebene dürfen gegenseitig importieren und exportieren

Sichtbarkeit/Initialisierungsreihenfolge

PROCEDURE P;.....

MODULE M;

MODULE M1

MODULE M3

BEGIN Anweisung;

END M

MODULE M2

Innere Module Qualifizierter Export

MODULE hello; IMPORT InOut; MODULE inner; EXPORT QUALIFIED a; VAR a : INTEGER; BEGIN a := 1; END inner; VAR a :INTEGER; BEGIN a := 0; InOut.WriteInt(a,3); InOut.WriteInt(inner.a,3); END hello.

Unqualifizierter Export

MODULE hello; IMPORT InOut; MODULE inner; EXPORT a; VAR a : INTEGER; BEGIN a := 1; END inner; VAR a :INTEGER; BEGIN a := 0; InOut.WriteInt(a,3); InOut.WriteInt(inner.a,3); END hello.

Externe Module DEFINITION MODULE item; TYPE index = INTEGER; item = RECORD key: index END; PROCEDURE ReadItem(): item; END item.

(*Schnittstellen in „def“ Datei speichern*) IMPLEMENTATION MODULE item; FROM InOut IMPORT WriteLn, WriteString, ReadInt, WriteInt; PROCEDURE ReadItem(): item; ... BEGIN … END ReadItem; END item.

Undurchsichtige Datentypen Definition eines Typnames in Definitonsmoduln ohne Bindung an einen

konkreten Datentyp.realisieren ADT. Die konkrete Deklaration eines undurchsichtigen Datentyps ist auf POINTER-Typen beschränkt. DEFINITION MODULE Test; TYPE zahl; PROCEDURE Readnum(zahl); END test. IMPLEMENTATION MODULE Test; TYPE zahl =POINTER TO zahlfolge; zahlfolge=RECORD vor:CARDINAL; nach:REAL; END;............

Symbol Name ident=letter{letter|digit} Zahlen (ganzen Zahlen,Gebrochene Zahlen) Zeichenketten „“ oder‚‘ Operatoren und Schlüsselwörter

:=,=,#(ungleich),~, ^,IN FOR,FROM,IF,IMPLEMENTATION,IMPORT, ELSIF,OF ,OR,WHILE,WITH,PRPZEDURE,POINTER, PROZESS,UNTIL,VAR,RECORD,SET,MODULE,MOD...

Kommentare (* mmmmmmmmm*) dürfen geschachtelt sein (*ccc(aa)(*ss*)*)

Unstrukturierte Datentypen vordefinierte Datentypen : INTEGER, LONGINTEGER,CARDINAL, REAL, BOOLEAN, CHAR, BITSET. BITSET

{2,4,6}, {}, {0..15} (bei 16-Bit Rechnern), {0..31} (bei 32-Bit Rechnern) CARDINAL:

Alle positiven ganzen Zahlen (einschließlich Null).

nicht vordefinierte Datentypen : Aufzählungstypen

Material = (eisen, stahl, kupfer, glas, gummi) Unterbereichstypen, Minimal – und Maximalwert:

[0 .. 9]; [„0“ .. „9“]; [0C .. 177C]; [FALSE .. TRUE]; INTEGER[1 .. 1000]; [0 .. 40000]; [-10 .. +10] Ungültig: [ „A“ .. „9“] [1.5 ..2.5]

Strukturierte Datentypen Array, Record, Pointer, SET-Type

n, Prozedur-Typ

TYPE Name = ARRAY[1 .. 20],[0 .. 19] OF CHAR TYPE Name =ARRAY CHAR OF [0

.. 9]

Ungültig mit Index-Typ: ARRAY BITSET OF INTEGER, AR

RAY CARDINAL OF INTEGER TYPE Datum = RECORD Tag :

[1..31];Monat:[Jan .. Dez];Jahr :[1900..2006]

TYPE ptr = POINTER TO Datum;

POINTER ist an einen bestimmten Datentyp (seinen Basistyp) gebunden.

SET OF [3 ..5] SET OF [eisen .. kupfer] Ungülitge: SET OF [-1 .. +1] SET OF CHAR nur Aufzählungs-

und Unterbereichstypen erlaubt.

TYPE winkelfunktion =PROCEDURE (REAL):REAL;

Zuweisung Designator „:=“ Expression. Beispiele:

set:={1,2,3,4,5}; a[i] :=„A“; p^.t :=2;

Prozedurekonzepte PROCEDURE Vertauschen(VAR Var1, Var2: Art); VAR ZwischenVar: Art; BEGIN

ZwischenVar := Var1; Var1 := Var2; Var2 := ZwischenVar

END Vertauschen; PROCEDURE Maximum(Zahl1, Zahl2: INTEGER): INTEGER;

TYPE F: PROCEDURE(VAR INTEGER, INTEGER): INTEGER; VAR funk: F; funk := Maximum;

Steuerstruktur Bedingte Anweisungen IF, CASE Wiederholungsanweisungen WHILE, FOR, REPEAT, LOOP Kein “GOTO”

IF THEN IF Betrag < 0 THEN AenderungKontostand := TRUE; Soll := Soll + (-Betrag) ELSIF Betrag > 0 THEN AenderungKontostand := TRUE; Haben := Haben + Betrag ELSE AenderungKontostand := FALSE END

CASE

Beispiel:

CASE Operator OF '+': Ergebnis := Zahl1 + Zahl2 | '-': Ergebnis := Zahl1 - Zahl2 | '*': Ergebnis := Zahl1 * Zahl2 | '/': Ergebnis := Zahl1 / Zahl2 | ELSE Fehler := TRUE END; ……………………

WHILE a<b DO a:=a+1; b=b-1; END

FOR TestTeiler := 2 TO Zahl-1 BY 1 DO IF Zahl MOD TestTeiler = 0 THEN Primzahl := FALSE; WriteCard(TestTeiler, 1); WriteLn END

WHILE FOR

Loop

LOOP WriteLn; ReadInt(Zahl); ………………. Read(Antwort); Read(Zeichen); IF NOT (Antwort = JaAntwort) AND (Zeichen = EOL) THEN EXIT END …………………….

Repeat Until

REPEAT WriteString("Bitte eine ganze Zahl und Return eingeben: "); Read(Antwort); Read(Zeichen) UNTIL NOT (Antwort = JaAntwort) AND (Zeichen = EOL); WriteString("Ende!"); END; ………………………………

Prozess Niedrige Ebene, keine Prozeßsynchronisation und –kommunikation. Nur durch Implementierung höherer Konzepte realisiert. Bsp: Modulrumpf := p1. Consumer := c. MODULE test; VAR workspace[1 .. 50 ] OF CARDINAL; p1,c:PROCESS; PROCEDURE Consumer; BEGIN LOOP Write(char);TRANSFER (c,p1); END END Consumer; BEGIN NEWPROCESS(Consumer,ADR(workspace),SIZE(workspace),c); LOOP Read(char);(*LOOP ohne Exit,zeichnet “p1” Prozess.*) TRANSFER(p1,c); END END test..

Prozess Unterbrechung und Prioritäten Prozess wird von außen zu unterbrochen. Auslöser meist ein Hardware-Signal, das einen Prozeduraufruf auslöst Interupt-Handler muss bereitgestellt werden. Priorität ist eine Konstante vom Datentyp CARDINAL. Module Clock[7]; Var timer,interrupted :PROCESS; workspace :ARRAY [1 .. 100] OF CARDINAL; PROCEDURE EverySecond; BEGIN LOOP IOTRANSFER(timer,interrupted,24);... END BEGIN NEWPROCESS(EverySecond,ADR(workspace),SIZE(workspace),timer); TRANSFER(interrupted,timer); END Clock;

Termination HALT: unnormale Termination ,Ganz

Programm wird abgebrochen. FINALLY: normale Termination, Mech

anismus ,Mühl zu aufräumen . MODULE DistinguishHalt; FROM TERMINATION IMPORT HasHalted; IMPORT STextIO; VAR ch : CHAR; BEGIN STextIO.WriteString ("Halt? Y/N => "); STextIO.ReadChar (ch); STextIO.SkipLine; IF CAP (ch) = "Y" THEN HALT END;

FINALLY IF NOT HasHalted () THEN STextIO.WriteString ("Not "); END; STextIO.WriteString ("Halted"); STextIO.WriteLn; STextIO.WriteString ("Press a return to contin

ue"); STextIO.SkipLine;

END DistinguishHalt.

MergeSort PROCEDURE MergeSort (VAR source: ARRAY OF CARDINAL; lBoun

d, uBound : CARDINAL); PROCEDURE Merge (VAR source: ARRAY OF CARDINAL; left, mid, r

ight : CARDINAL); VAR countS1, countS2, temp : CARDINAL; BEGIN countS1 := left; WHILE countS1 <= mid DO IF source [countS1] > source [mid + 1] THEN temp := source [countS1]; source [countS1] := source [mid + 1];

MergeSort countS2 := mid + 2; WHILE (countS2 <= right) AND (temp > source [countS2]) DO

source [countS2 - 1] := source [countS2]; INC (countS2); END; source [countS2 - 1] := temp; END; INC (countS1); END;

END Merge;

MergeSort VAR middle : CARDINAL; BEGIN IF lBound >= uBound THEN RETURN END; middle := (lBound + uBound) DIV 2; MergeSort (source, lBound, middle); MergeSort (source, middle + 1, uBound); Merge (source, lBound, middle, uBound); END MergeSort;

OOM-2 MODULE TestRectangleClass1; IMPORT SWholeIO; TRACED CLASS rectangle; REVEAL SetDims, Area, sides; CONST sides = 4; VAR length, width : INTEGER; PROCEDURE SetDims (len, wid : INTEGER); END SetDims; … PROCEDURE Area () : INTEGER; END Area;… BEGIN (* initialization *) SetDims (0,0); END rectangle; VAR theRect : rectangle; BEGIN (* main *) CREATE (theRect); SWholeIO.WriteInt (theRect.Area(), 10); theRect.SetDims (4, 3); SWholeIO.WriteInt (theRect.Area(), 10); END TestRectangleClass1.

Kompilierung und Ausführung moorea: % gpmake prog11 ## compiling item.def ... ## compiling item.mod ... ## building prog11 ... moorea: % prog11 8 Sätze eingeben: 11 33 22 55 77 44 9 0 11 33 22 55 77 44 9 0 moorea: % ** Sprache Version**: Volition Systems ,Logitech(PC-DOS,CP/M) , Modula Research Inititute

Literatur Modula-2 Quelle: Modula-2 (Springer): Rohlfing-Brosell,H(BDR) Algorithmen und Datenstrukturen mit Modula-2 :Niklaus Wirth Softwaretechnik und Modula-2 :Gustav Pomberger http://www.cs.inf.ethz.ch/~wirth/ http://www.csc.twu.ca/rsbook http://www.modula2.org/tutor/ Kompiler(windows) http://freepages.modula2.org/compi.html http://home.perm.ru/~strannik/ http://sourceforge.net/projects/mide3de2/ http://www.excelsior-usa.com/xdsx86win.htmll Linux http://www.nongnu.org/gm2/ http://floppsie.comp.glam.ac.uk/Glamorgan/gaius/ Niklaus ： wirth @ inf.ethz.ch