PL/I für Workstations: Einführung in die „neue“ Sprache

292 Pages·1999·8.958 MB·German

by  Eberhard Sturm (auth.)

Eberhard Sturm
PLI I
für Workstations
Aushildung und Studiium
Die Bücher der Reihe "Ausbildung und Studium" bieten praxisonentierte Einführungen
für die Aus- und Weiterbildung sowie Bausteine für ein erfolgreiches berufsqualifI
zierendes Studium.
Unter anderem sind erschienen:
Studlen-und Forschungllflihrer
Informatik an Fachhochschulen
von Rainer Bischoff (lirsg.)
Turbo Pascal Wegweiser für Ausbildung und Studium
von Ekkehard Kaier
Deiphi Essentials
von Ekkehard Kaier
Programmieren mit Fortran 90
von Hans-Peter Bäumer
WIrtschaftsmathematIk mit dem Computer
von Hans Benker
Datenbank-Engineering
von Alfred Moos und Gerhard Daues
Vlsual Basic Essentials
von Ekkehard Kaier
Excel für Betriebswirte
von Robert Horvat und Kambiz Koochaki
Grundkurs WIrtschaftsinformatik
von Dietmar Abts und Wilhelm Mülder
Praktische Systemprogrammierung
von Helmut Weber
Ingenieurmathematik
mit Computeralgebra-Systemen
von Hans Benker
Excel für Techniker und Ingenieure
von Hans-Jürgen Holland und Uwe Bernhardt
Relationales und obJektrelatlonales SQL
von Wolf-Michael Kähler
KostensteUenrechnung mit SA"-R/38
von Franz Klenger und Ellen Falk Kalms
Theorie und Praxis relatlonaler Datenbanken
von Rene Steiner
OBERON
von B. Marincek, I.L. Marais und E. Zell er
Studienführer WIrtschaftsinformatik
von Peter Mertens, Peter Chamoni, Dieter Ehrenberg,
Joachim Griese, Lutz j. Heinrich und Karl Kurbel (Hrsg.)
Einführung In UNIX
von Werner Brecht
Grundkurs JAVA
von Dietmar Abts
ObjektorIentierte Programmierung In JAVA
von Otto Rauh
PL/I für Workstations
von Eberhard Sturm
Vieweg
Eberhard Sturm
PL/I
für Workstations
Einführung in die "neue" Sprache
4., verbesserte und erweiterte Auflage
aI
vleweg
Die Deutsche Bibliothek - CIP-Einheitsaufnahme
Ein Titeldatensatz für diese Publikation ist bei der
Deutschen Bibliothek erhältlich.
1. Auflage 1990
2., verbesserte Auflage 1992
3., verbesserte und erweiterte Auflage 1997
4., verbesserte und erweiterte Auflage 1999
Alle Rechte vorbehalten
©Springer Fachmedien Wiesbaden 1999
Ursprünglich erschienen bei Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, BraunschweiglWiesbaden,1999.
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt.
Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes
ist ohne Zustimmung des Verlags unzulässig und strafbar. Das gilt insbe
sondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und
die Einspeicherung und Verarbeitung in elektronischen Systemen.
http://www.vieweg.de
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem
Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche
Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten
wären und daher von jedermann benutzt werden dürften.
Höchste inhaltlicheund technische Qualität unserer Produkte ist unser Ziel. Bei der Produktion
und Auslieferung unserer Bücher wollen wir die Umwelt schonen: Dieses Buch ist auf säure
freiem und chlorfrei gebleichtem Papier gedruckt. Die Einschweißfolie besteht aus Polyäthylen
und damit aus organischen Grundstoffen, die weder bei der Herstellung noch bei der
Verbrennung Schadstoffe freisetzen.
Konzeption und Layout des Umschlags: U1rike Weigel, www.CorporateDesignGroup.de
Gedruckt auf säurefreiem Papier
ISBN 978-3-528-34792-5 ISBN 978-3-663-01512-3 (eBook)
DOI 10.1007/978-3-663-01512-3
v
Vorwort
Kann ein PLII-Buch in anderthalb Jahren veralten?
Diese Frage ist natürlich nicht ernsthaft mit ja zu beantworten. Aber seit der letzten Auflage
hat sich so viel geändert, dass ein einfacher Nachdruck nicht in Frage kam.
Der neue Workstation-Compiler der Fa. IBM, der zunächst nur für das Betriebssystem OS/2
lieferbar war, hat inzwischen seinen Weg gemacht über Windows und AIX (der Unix-Ver
sion von IBM) auf den sogenannten Mainframe, das Betriebssystem OS/390. In der Zukunft
ist sogar eine Linux-Version zu erwarten.
Damit einher ging die Weiterentwicklung der Sprache. Konnten in der letzten Auflage
schon "neue" Konzepte wie abstrakte Datentypen vorgestellt werden, so liegt die Betonung
in dieser Auflage auf der Berücksichtigung unterschiedlicher Sprachstandards. Gab es beim
Großrechner-Compiler nur den IBM-Standard, so erlaubt der Workstation-Compiler auch
die Benutzung des ANSI-Standards. In jedem Fall werden bei Unterschieden beide Stan
dards vorgestellt. Auch wegen Neuerungen wie dem Datentyp FIXED BIN (63) ist der
Abschnitt über Rechenregeln kaum wiederzuerkennen.
Von den neuen BUILTIN-Funktionen sei hier nur CHECKSTG erwähnt, dessen Fähigkei
ten an den alten Checkout-Compiler erinnern: Endlich kann man kontrollieren, ob Zeigerva
riablen eine gültige Adresse enthalten.
Auch Compiler-Optionen sind hinzugekommen. Fast jede Art laxer Verwendung von
Sprachmittein kann man sich jetzt vom Compiler monieren lassen, und wenn es die Benut
zung der GOTO-Anweisung ist. Vollständig sind jetzt auch die Möglichkeiten, das Jahr-
2000-Problem in den Griffzu bekommen. PLII stellt hier eine Kombination von BUILTIN
Funktionen und Compiler-Optionen zur Verfügung.
Viele Abschnitte wurden erweitert, etwa der über FETCH und RELEASE. Auch wurde
neuen Entwicklungen Rechnung getragen, etwa beim Präprozessor oder der Benutzung des
€-Symbols in PICTURE-Angaben.
Das vorliegende Buch soll in diesem Sinne eine modeme Einführung in die "Programming
Language" Nummer 1 bieten. Beabsichtigt ist sowohl, Anfängern ein Selbststudium zu
ermöglichen, als auch, Profis mit neuen Ideen zu versorgen, letzteres auf Grund der umfas
senden Darstellung der Sprache. Sollte einem erfahrenen PLII-Programmierer ein Beispiel
unverständlich vorkommen, so hoffe ich, dass es daran liegt, dass etwas Neues in die Spra
che aufgenommen wurde.
Erwarten Sie also keine theoretische Erörterung über Algorithmen oder Struktogramme,
sondern eine praktische Einführung, die es Ihnen ermöglichen soll, konkrete Probleme mit
Hilfe von PLII auf übersichtliche Weise zu lösen! Ich werde - im Gegensatz zu einem "Re
ference Manual" - immer erwähnen, welche Verwendung von Sprachmittein "gut" und wel
che "böse" ist.
Alle Beispiele und das im letzten Kapitel erwähnte PARSE-Makro finden Sie im WWW
unter:
http:\\www.uni-muenster.de\ZIV\Mitarbeiter\EberhardSturm.html
VII
Inhalt
Vorwort ................................................................................................................................... 5
Einleitung ................................................................................................................................ 1
I. Elementares PL/I. ............................................................................................................... 3
1.1 Die Programmierumgebung ........................................................................................ 3
1.1.1 Oberste Instanz - das Betriebssystem .............................................................. 3
1.1.2 Wie läuft's - Programm und Compiler. ........................................................... 3
1.2 Datenattribute ............................................................................................................ .5
1.2.1 An zentraler Stelle - der Hauptspeicher. ......................................................... 5
1.2.2 Ganze Arbeit - Festkommazahlen ................................................................... 6
1.2.3 In die Brüche - Gleitkommazahlen ............................................................... 10
1.2.4 Eine Sprache mit Charakter - Zeichenfolgen ................................................ 12
1.2.5 Kleiner geht's nicht - Bits .............................................................................. 15
1.2.6 Jeder mit jedem - Operatoren ........................................................................ 16
1.3 Schleifen ................................................................................................................... 18
1.3.1 Erst fragen - die WHILE-Schleife ................................................................. 19
1.3.2 Erst schießen - die UNTIL-Schleife .............................................................. 20
1.3.3 Aufwärts und abwärts - die Zählschleife. ...................................................... 21
1.4 Ein- und Ausgabe ...................................................................................................... 22
1.4.1 Hier gibt's was zu holen - die GET- Anweisung ............................................ 22
1.4.2 Nichts mehr da - die ON-Anweisung ............................................................ 24
1.5 Fallunterscheidungen ................................................................................................ 26
1.5.1 Entweder, oder - die IF-Anweisung .............................................................. 26
1.5.2 Von Fall zu Fall - die SELECT-Gruppe ........................................................ 29
2. Erweiterung der Grundlagen ............................................................................................ 35
2.1 Ein-und Ausgabe eines Zeichenstroms .................................................................... 35
2.1.1 Damit ist nicht zu rechnen - das FILE-Attribut... .......................................... 35
2.1.2 Selbstbestimmung - EDIT- gesteuerte Ein-/A usgabe ..................................... 3 7
2.1.3 Eine Sprache für sich - Datenformate .......................................................... .41
2.2 Die allgemeine Schleife ........................................................................................... .45
2.2.1 Endlos - LOOP und Zubehör. ...................................................................... .45
2.2.2 Die ganze Wahrheit - DO allgemein ............................................................ .47
2.3 Matrizen .................................................................................................................... 50
2.3.1 Tausend oder eine Variable - Arbeiten mit Matrizen ..................................... 50
2.3.2 Im Konvoi - Matrixoperationen .................................................................... 53
2.3.3 Nicht nur für Mathematiker - mehrere Dimensionen .................................... 54
2.3.4 Die Letzten laufen am schnellsten - das INITIAL-Attribut... ....................... 56
2.4 Strukturen ................................................................................................................ .58
2.4.1 Hierarchien beachten - Arbeiten mit Strukturen ........................................... 58
2.4.2 Warum auch nicht - die Strukturmatrix ......................................................... 62
2.4.3 Auch das noch - Mehrfachdeklarationen ....................................................... 63
2.5 Manipulation von Zeichenfolgen .............................................................................. 66
2.5.1 Zwei reichen völlig - SUBSTR und LENGTH ............................................. 66
2.5.2 Wo und wie häufig - INDEX und TALLy. .................................................. 68
2.5.3 Hokus Pokus - TRANSLATE ....................................................................... 69
VIII Inhalt
2.5.4 Vorwärts und riickwärts - VERIFY(R) und SEARCH(R) ............................ 71
2.5.5 Was ihr wollt - weitere Funktionen ............................................................... 74
2.5.6 Sich selbst ein Bild machen - PICTURE-Zeichenfolgen .............................. 75
2.5.7 Ohne Umweg - STRING statt FILE .............................................................. 76
2.6 Arithmetik ................................................................................................................. 76
2.6.1 Auf welcher Basis - das FIXED-Attribut... ................................................... 77
2.6.2 Verschwindend gering - das FLOAT-Attribut... ........................................... 81
2.6.3 Arithmetische Mittel - Rechenregeln und Fallstricke ................................... 83
2.6.3.1 Gemischte Operationen ........................................................................... 84
2.6.3.2 FLOAT-Operationen ............................................................................... 84
2.6.3.3 FIXED-Operationen im ANSI-Standard ................................................. 84
2.6.3.4 FIXED-Operationen im IBM-Standard .................................................. 85
2.6.3.5 Spracheigene Funktionen ........................................................................ 86
2.6.3.6 Das Default-Konzept. .............................................................................. 87
2.6.4 Janusköpfig - PICTURE-Zahlen ................................................................... 88
2.6.5 Nichts Reelles - Komplexe Zahlen ................................................................ 93
2.7 Manipulation von Bitfolgen ...................................................................................... 95
2.7.1 Über kurz oder lang - BIT-Operationen ........................................................ 95
2.7.2 Mengenlehre - Arbeiten mit Bitfolgen .......................................................... 97
2.7.3 Die Maschine naht - UNSPEC und andere ................................................... 98
2.8 Abstrakte Datentypen ............................................................................................. 10 I
2.8.1 Typen mit Decknamen - DEFINE ALIAS .................................................. 101
2.8.2 Farbe bekennen - Aufzählungstypen ........................................................... 102
2.8.3 Starke Typen - DEFINE STRUCTURE ...................................................... 105
2.9 Zeitberechnungen. ................................................................................................... 10 6
2.9.1 Der Schrecken der Jahrtausendwende - Datum und Uhrzeit ....................... 106
2.9.2 Eine Sprache mit SECS - das Lilianische Format ....................................... 107
2.9.3 Rache des Ererbten - Umwandlung von Jahreszahlen ................................ 108
3. Block-und Programmstruktur. ....................................................................................... 111
3.1 Geltungsbereich und Lebensdauer von Variablen .................................................. 111
3.1.1 Nützlicher Wasserkopf - Der BEGIN-Block ............................................... 111
3.1.2 Mehr als einmal - Der PROCEDURE-Block. ............................................. 112
3.1.3 Auf der Hut - Schachtelung von Blöcken ................................................... 113
3.2 Struktur eines PUl-Programms .............................................................................. 115
3.2.1 Auf die Reihenfolge kommt es an - Parameter. .......................................... 115
3.2.2 Einbahnstraße - Scheinargumente ............................................................... 118
3.2.3 (Nicht) von Dauer - AUTOMATIC und STATIC ...................................... 119
3.2.4 Selbst gemacht - Funktionen ....................................................................... 121
3.2.5 Wie bei Münchhausen - rekursive Prozeduren ............................................ l24
3.2.6 Getrennt übersetzen, vereint ausführen - externe Prozeduren ..................... 127
3.2.7 Prozeduren im Paket - PACKAGE ............................................................. 131
3.2.8 Dynamische Ladung - FETCH, RELEASE und DLLs ............................... 138
3.3 Ausnahmebedingungen ........................................................................................... 141
3.3.1 Vorsorglich - Handhabung von Bedingungen ............................................. 141
3.3.2 Auch römische Zahlen - Berechnungsbedingungen .................................... 147
3.3.3 Unheimliche Begegnung - der Programm-Test... ........................................ l51
Inhalt IX
3.3.4 Roter Alann - restliche Bedingungen .......................................................... 157
4. Dynamische Speicherplatzverwaltung. .......................................................................... 163
4.1 Das CONTROLLED-Attribut. ................................................................................ 163
4.1.1 Nur auf Wunsch - ALLOCATE und FREE ................................................ 163
4.1.2 Eine neue Konstruktion - der StapeL ........................................................ .165
4.1.3 Allgemeiner geht's nicht - das INITIAL-CALL-Attribut... ......................... 169
4.2 Das BASED-Attribut. ............................................................................................. 170
4.2.1 Adressen _ dynamische Speicherplatzinterpretation ................................... 170
4.2.2 Mit Papier und Bleistift - lineare Listen ...................................................... 173
4.2.3 In die Botanik - allgemeine Listen .............................................................. 179
4.3 Das AREA-Attribut. ............................................................................................... 184
4.3.1 Gute Nachbarschaft _ Benutzung von Gebieten .......................................... 185
4.3.2 Lücken schließen - Speicherbereinigung. ................................................... 186
4.4 Dynamik bei Strukturtypen ..................................................................................... 192
4.4.1 Mit sicherem Griff - das HANDLE-Attribut... ............................................ 192
4.4.2 Völlig neu - Typfunktionen ......................................................................... 194
5. Benutzung von Dateien .................................................................................................. 197
5.1 PLII-Dateien ........................................................................................................... 197
5.1.1 Verallgemeinert - Dateiwerte ...................................................................... 197
5.1.2 Alternativ und additiv - Dateiattribute ........................................................ 198
5.1.3 Geht auch automatisch - Öffnen und Schließen .......................................... 199
5.2 Ein-und Ausgabe von Sätzen ................................................................................. 203
5.2.1 Vielfältig - Datenbestände ........................................................................... 203
5.2.2 Hintereinander - CONSECUTIVE-Datenbestände ..................................... 205
5.2.3 Durchnummeriert - REGIONAL(I)-Datenbestände ................................... 208
5.2.4 Nach Belieben - VSAM-Datenbestände ...................................................... 211
5.2.4.1 organization (consecutive) ..................................................................... 212
5.2.4.2 organization (relative) ........................................................................... 214
5.2.4.3 organization (indexed) ........................................................................... 215
5.3 Spezielle Möglichkeiten der Ein-und Ausgabe ...................................................... 217
5.3.1 Direkt - LOCATE-Modus ........................................................................... 217
5.3.2 Unfonnatiert - FILEREAD und FILEWRITE ............................................ 220
5.3.3 Der Reihe nach - PLISRTx ......................................................................... 222
6. Spezielle PL/I-Techniken ............................................................................................... 225
6.1 Matrixausdrücke ..................................................................................................... 225
6.1.1 Ein guter Tipp - spracheigene Matrix-Funktionen ...................................... 225
6.1.2 Verallgemeinert - Matrix-Funktionswerte .................................................. .229
6.2 Variablendefinition ................................................................................................. 230
6.2.1 Gemeinsam in der Zelle - das UNION-Attribut... ... , ................................... 230
6.2.2 Neue Namen - Korrenspondenzdefinition ................................................... 231
6.2.3 Eine Frage der Position - Überlagerungsdefinition ..................................... 232
6.2.4 Überwältigend - iSUB-Definition ............................................................... 233
6.3 Systemnahes Programmieren .................................................................................. 235
6.3.1 C-Bits - Bitmanipulationen auf Zahlen ....................................................... 235
6.3.2 Anonym - Speichennanipulationen ............................................................. 236
6.3.3 Interna - fremde Datenfonnate .................................................................... 238
x
Inhalt
6.3.4 Mit System - API-Programmierung ............................................................ 240
6.4 Parallelverarbeitung ................................................................................................ 244
6.4.1 Zum Wiederbetreten - das TASK-Attribut... ............................................... 245
6.4.2 Ruck-zuck - Synchronisation von Fäden ..................................................... 248
6.5 Programmgenerierung zur Übersetzungszeit.. ........................................................ 251
6.5.1 Wie gehabt - Grundlagen der Makro-Sprache ............................................ 252
6.5.2 Wie gerufen - die Präprozessorprozedur ..................................................... 256
6.5.3 Selbst gebaut - Definition eigener Anweisungen ........................................ 258
Anhang A: Lösungsideen .................................................................................................... 263
Anhang B: Spracheigene FunktionenIRoutinen .................................................................. 267
Arithmetik ...................................................................................................................... 267
Bedingungen .................................................................................................................. 267
Ein!A usgabe ................................................................................................................... 268
Folgen ............................................................................................................................ 268
Ganzzahl-Manipulation ................................................................................................. 269
Genauigkeit. ................................................................................................................... 269
Gleitkomma-Abfrage (Konstanten) ............................................................................... 270
Gleitkomma-Manipulation ............................................................................................. 270
Mathematik. ................................................................................................................... 270
Matrix ............................................................................................................................ 271
Ordinalzahlen ................................................................................................................. 271
Speicherverwaltung ....................................................................................................... 271
Vermischtes ................................................................................................................... 273
Zeit ................................................................................................................................. 273
Pseudovariablen ............................................................................................................. 274
Routinen ......................................................................................................................... 274
Typfunktionen ................................................................................................................ 275
Makrofunktionen ........................................................................................................... 275
Index .................................................................................................................................... 277
Einleitung
Unter der "Philosophie" einer Programmiersprache versteht man die Ideen und Intentionen,
die zu ihrer Entstehung geführt haben und Grundlage ihrer Definition sind.
Die Hauptidee von PLiI ist die Universalität: Die Sprache stellt rür nahezu alle Gebiete heu
tiger Programmiertechniken Sprachmittel zur Verfügung, wahrt dabei aber weitgehend die
Orthogonalität, d. h. die verschiedenen Konzepte stören sich nicht gegenseitig, sondern
ergänzen sich sinnvoll. Irgendwelche Ausnahmen beruhen eher auf Zeitmangel der Compi
ler-Bauer wegen einer im Prinzip riesigen Programmiersprache als aufDesignfehlern.
An "Highlights" sind aufzuzählen:
Modularität: Programmteile sind getrennt übersetzbar.
Maschinenunabhängigkeit: Programme können so geschrieben werden, dass sie unabhän
gig davon, welcher Rechner benutzt wird, gleiche Ergebnisse liefern -
soweit möglich.
Maschinennähe: Wenn man irgendwelche Hardware-Gegebenheiten ausnutzen will,
kann man sogar einzelne Bits manipulieren.
Übersichtlichkeit: Die Konzepte der sogenannten strukturierten Programmierung können
(nicht: müssen) in PLiI verwirklicht werden.
Datentypenvielfalt: PLiI bietet von sich aus schon eine Vielzahl von Datentypen. Darüber
hinaus besteht die Möglichkeit, eigene Datentypen zu definieren.
Standardannahmen: Trotz des Umfangs der Sprache sorgt ein Konzept von Standardan
nahmen für eine Reduzierung des Schreibaufwands. Außerdem garan
tiert dieses Konzept, dass der AnHinger nicht durch Elemente der
Sprache gestört wird, die er gar nicht kennt!
Speicherdynamik: Die Zuordnung von Speicherplatz kann entsprechend den Erfordernis
sen des Problems flexibel gehandhabt werden. Hierzu stehen unter
schiedliche Speicherklassen zur Verfügung.
Ein-und Ausgabe: Im Vergleich zu anderen Programmiersprachen gibt es in PLiI sehr
ausgefeilte Methoden, Daten zu übertragen. Diese reichen vom einfa
chen Einlesen eines Zeichenstroms bis hin zu einem datenbankähnli
chen Zugriff. Sogar komplexe Datenstrukturen wie z. B. binäre Bäume
können effizient auf Magnetplatte gespeichert werden.
Fehlerbehandlung: In PLiI gibt es rür jeden Fehler eine Nummer, rür die wichtigsten auch
Namen. Das Programm kann flexibel darauf reagieren und sogar mit
der Verarbeitung fortfahren.
Erweiterbarkeit: Will man für besondere Probleme eigene Anweisungen definieren, so
ist auch das in PLiI möglich. Der sogenannte Präprozessor ist in der
Lage, diese neuen Sprachelemente in nonnale PLlI-Anweisungen
umzuwandeln.
E. Sturm, PL/I für Workstations
© Springer Fachmedien Wiesbaden 1999