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