Pascal (Programmiersprache)

Pascal ist eine Anfang der 1970er Jahre entwickelte imperative Programmiersprache.

Pascal
Paradigmen:	imperativ, strukturiert
Erscheinungsjahr:	1971
Designer:	Niklaus Wirth
Entwickler:	Niklaus Wirth
Typisierung:	stark, statisch
Dialekte:	UCSD-Pascal, Borland Pascal Turbo Pascal
Beeinflusst von:	ALGOL
Beeinflusste:	Modula-2, Ada, Oberon, Object Pascal, WEB, Seed7

Niklaus Wirth (2009), der Entwickler von Pascal

Pascal wurde von Niklaus Wirth an der ETH Zürich als Lehrsprache eingeführt, um die strukturierte Programmierung zu lehren.

Allgemeines

Pascal ist eine Weiterentwicklung von Algol 60. Es lehnt sich in seiner Syntax an die englische Grammatik an. Dies soll die Lesbarkeit für Programmiereinsteiger verbessern; Pascal ist daher als Lehrsprache geeignet. Seine Verbreitung in der professionellen Programmierung fand es als Borland/Turbo Pascal, später Object Pascal. Jene sind, gegenüber dem Ur-Pascal, wesentlich erweiterte Versionen.

Ein wichtiges Konzept der Fehlersicherheit, das Wirth zur Anwendung brachte, ist die starke Typisierung (englisch „strong typing“): Variablen sind bereits zur Übersetzungszeit einem bestimmten Datentyp zugeordnet, und dieser kann nicht nachträglich verändert werden. Typenstrenge bedeutet, dass Wertzuweisungen ausschließlich unter Variablen gleichen Typs erlaubt sind. In Pascal gibt es von diesem strikten Zwang lediglich wenige Ausnahmen:

• Wertzuweisungen der Form [Variable vom Typ real] := [Wert vom Typ integer].
• In Extended-Pascal Wertzuweisungen von ganzzahligen oder reellen Zahlen an Variablen vom Type Complex.
• Wertzuweisungen von eingeschränkten Wertebereichen eines ordinalen Typs. Beispiel: type int10 = 1 .. 10; Werte dieses Typs können dann Integervariablen zugewiesen werden.
• Wertzuweisungen von Mengen eines eingeschränkten Wertebereiches eines ordinalen Typs. Beispiel: type set10 = set of 1 .. 10; set20 = set of 1 .. 20; Werte des Typs set10 können dann Variablen des Typs set20 zugewiesen werden.
• Wertzuweisungen auf eingeschränkte Wertebereiche eines ordinalen Typs oder einer Menge. In diesem Fall rufen Werte bzw. Mengen-Elemente außerhalb des Zielbereichs einen Laufzeitfehler hervor.
• Wertzuweisungen zwischen unterschiedlichen String-Typen, inkl. Char, Zeichen-Arrays gemäß Standard-Pascal und den verschiedenen String-Typen in Extended-Pascal, Borland Pascal usw. Sofern die Länge des Wertes nicht innerhalb der Kapazität des Ziels liegt, ergibt sich auch hier ein Laufzeitfehler.

Heute findet Pascal noch im universitären Bereich (Entwicklung/Ausbildung) und in sicherheitskritischen Bereichen (z. B. Verkehrstechnik, Energieversorgung, Medizintechnik, Raumfahrt, Militär, teilweise im Banken- und Versicherungswesen) Anwendung. Dies beruht hauptsächlich auf der guten Prüfbarkeit und Wartbarkeit des Codes und der klaren Zuordnung der Variablen. So war die 2005 eingeführte Betriebsleittechnik IV der 2011 stillgelegten Transrapid-Versuchsanlage Emsland in Pascal programmiert. Eine pascalähnliche Notation wurde in der Informatik und Mathematik zur Darstellung von Algorithmen benutzt. Aus didaktischen Gründen, es seien hier die Typstrenge, Fehlersicherheit und frei verfügbare portierbare Pascalcompiler (Free Pascal, GNU Pascal) genannt, wird im aktuellen Informatikunterricht Pascal ebenfalls noch eingesetzt. Im Hobby-Bereich erlangte Pascal zeitweilig eine weite Verbreitung.

Syntax

Hallo Welt

Ein Hallo-Welt-Programm sieht in Pascal folgendermaßen aus:

 program Hallo(output);  begin  writeln('Hallo Welt')  end. 

In neueren Pascal-Versionen sieht das Programm so aus:

 program Hallo;  begin  writeln('Hallo Welt')  end. 

Ein Detail am Rande: In manchen alten Beispielen findet man ein READLN nach dem WRITELN-Befehl. Das war nur notwendig, weil die I/O-Architektur der CDC Cyber 6000, auf der Wirth den ersten Pascal-Compiler entwickelte, das benötigte, um die internen Puffer zu leeren – sonst wäre im interaktiven Betrieb keine Ausgabe zu sehen gewesen. IDEs (integrierte Entwicklungsumgebungen) konnte man mit diesem READLN zwingen, am Ende der Programmausführung nicht sofort wieder in den Editor-Modus umzuschalten, was die Ausgabe bei manchen IDEs (z. B. Turbo-Pascal) sonst hätte verschwinden lassen. Im Batch-Betrieb war das ohnehin nie notwendig.

Datentypen

Standarddatenypen

Datentyp	Werte
integer	Ganze Zahlen, etwa 4, 0 oder -17
real	Gleitkommazahlen, etwa 0.4 oder -17.74445
boolean	die Werte true und false
char	ein einzelnes Zeichen, etwa a oder f

Jeder Variablen muss in einer Variablendeklaration ein Datentyp zugeordnet werden. Der Datentyp bestimmt, welche möglichen Werte die Variable während des Programmablaufs speichern kann. In Pascal gibt es vier einfache Standardtypen, nämlich integer, real, boolean und char.

Die Länge der verschiedenen Datentypen außer boolean sind abhängig vom Compiler. Weiterhin haben viele Implementationen noch weitere vordefinierte einfache Datentypen.

Selbstdefinierte Datentypen

In Pascal ist es möglich, neben den vier Standardtypen eigene einfache Datentypen zu definieren. Dabei handelt es sich entweder um Aufzählungstypen oder Ausschnittstypen. Um einen neuen Aufzählungstyp zu definieren, schreibt man alle Werte, die eine Variable dieses Typs speichern können soll, der Reihe nach auf. Im folgenden Beispiel wird ein neuer Typ mit dem Namen tBesteck definiert, wobei das optionale t am Anfang für den weiteren Programmverlauf klarstellen soll, dass es sich um einen Namen eines Typs handelt: tBesteck = (Gabel, Messer, Loeffel)

Einen Ausschnittstyp definiert man, wenn der Wertebereich eines umfassenderen Typs nicht voll ausgeschöpft wird. Wenn eine Variable beispielsweise nur die Zahlen zwischen 0 und 255 speichern können soll, so ist es möglich, den Datentyp integer auf diese Teilmenge einzuschränken. Im folgenden Beispiel wird ein neuer Typ mit dem Namen tByte definiert: tByte = 0 .. 255;

Strukturierte Datentypen

Pascal bietet Programmierern vier strukturierte Datentypen, die es ermöglichen, mehrere Werte in einer Variablen zu speichern. In einem Feld (array) kann eine feste, also während der Laufzeit unveränderbare Anzahl von Werten gespeichert werden, die alle vom selben Datentyp sein müssen. Im folgenden Beispiel wird ein Feld definiert, in dem maximal 100 ganze Zahlen abgespeichert werden können:

tBeispielFeld = array [1..100] of integer; 

In einer Menge (set) können ebenfalls Werte vom selben Datentyp gespeichert werden, allerdings wird nur festgehalten, welche Werte in der Menge enthalten sind, wobei es nicht darauf ankommt, wie oft ein einzelner Wert genannt wurde oder in welcher Reihenfolge die Werte genannt wurden. Ein Beispiel für die Definition einer Menge:

tBeispielMenge = set of 13..55 

In einem Verbund (record) kann eine feste Anzahl von Werten gespeichert werden, wobei die Werte von verschiedenem Datentyp sein dürfen. Ein Beispiel einer Definition:

tPerson = record  Alter : 0..150;  Haarfarbe : (braun, blond, schwarz);  Groesse : real;  kurzsichtig : boolean end; 

Eine beliebig lange Folge von Werten desselben Typs kann in Pascal mithilfe des Datentyps Datei (file) dargestellt werden. Beispiel einer Definition:

tBeispielDatei = file of integer 

Zeiger

Hauptzweck der Verwendung von Zeigern ist in Pascal das Erstellen von verschiedenen Datenstrukturen, je nach den Vorstellungen des Programmierers. So lassen sich mithilfe von Zeigern etwa Listen und Bäume erstellen, die bei der Speicherung von Daten Vorteile gegenüber Feldern, Mengen, Verbünden und Dateien bieten. Ein weiterer Vorteil von Zeigern ist, dass Zeigervariablen den von ihnen benötigten Speicherplatz während der Laufzeit anfordern können. Der Programmierer muss also nicht schon im Vorhinein definieren, wie viel Platz die Variablen seines Programms bei der Ausführung benötigen werden und kann grundsätzlich vom Minimum ausgehen, über das, je nach Bedarfsfall, hinaus erweitert wird.

Programmstrukturen

Charakteristisch für Pascal ist das Konzept der Verschachtelung von Prozeduren und Funktionen. Im Deklarationsteil einer Prozedur oder Funktion können andere Prozeduren und Funktionen definiert werden, die außerhalb nicht sichtbar sind. Beispiel:

program HalloWelt;  procedure foo;  procedure bar;  begin  writeln('Hallo Welt');  end;  begin  bar  end; begin  foo; (* kein Compilerfehler *)  bar (* Compilerfehler, da bar nicht sichtbar *) end. 

Kontrollstrukturen

Bedingte Anweisung und Verzweigung

Als bedingte Anweisungen und Verzweigungen stehen in Pascal die if- und die case-Anweisung zur Verfügung. Ein Beispiel einer if-Verzweigung:

if 1 = 2 then  writeln ('wird nicht ausgeführt') else if 1 = 1 then  writeln ('wird ausgeführt') else  writeln ('wird nicht ausgeführt'); 

Schleifen

Pascal bietet drei Arten von Schleifen. Soll vor jedem Schleifendurchlauf eine Abbruchbedingung geprüft werden, verwendet man die while-Anweisung, für eine Prüfung nach jedem Durchlauf die repeat-Anweisung. Für eine vorgegebene Anzahl von Durchläufen gibt es die for-Anweisung.

while wert < 100 do  wert := wert + 1; 

for i:= 1 to 100 do  wert := wert + 1; 

repeat  wert := wert + 1  until wert > 100; 

Die WITH-Anweisung ist keine Schleife, sie vereinfacht nur die Zugriffe auf Komponenten eines Record.

Sprunganweisungen können mit goto auch verwendet werden, dessen Gebrauch jedoch umstritten ist (siehe Artikel zu Sprunganweisungen).

Compiler

Pascal-Compilern sind überwiegend Single-Pass-Compiler, d. h. die Quelle wird nur ein einziges Mal gelesen und analysiert. Das Design der Sprache war so gehalten, um genau das zu ermöglichen. Bei der damaligen geringen Geschwindigkeit der Rechner Anfang der 1970er Jahre war dies ein großer Vorteil.

Der erste Pascal-Compiler entstand auf der CDC Cyber 6000 der ETH Zürich. Daraus entstand dann Pascal 6000, das als erste operative Version eines Compilers der Sprache gesehen werden kann.

Ein zweiter Pascal-Compiler – der P4 „Portable Pascal Compiler“ von Urs Ammann, Kesav Nori und Christian Jacobi – stammte ebenfalls von der ETH Zürich. Der P4 erzeugte eine plattformunabhängige, als Assemblersprache ausgelegte Zwischensprache, den P-Code, der durch eine virtuelle Maschine (ein Programm) interpretiert wird. Später entstanden dann Compiler, die auf dem P4 basierten. Die verbreitetste Version wurde unter dem Namen UCSD Pascal bekannt, das auf vielen Systemen implementiert wurde, u. a. auf Apple II und Texas Instruments TI-99/4A und wesentlich zur Verbreitung der Sprache sowohl (zuerst) in den Vereinigten Staaten, später auch in Europa beitrug. Im Mai 2006 wurden die Quelltexte von UCSD Pascal freigegeben.

Besonderheiten

Sehr hohe Prozesssicherheit

Da Pascal sowie der Quasi-Standard Borland/Turbo-Pascal eine strikte Trennung unterschiedlicher Typen vorsehen und die Zuweisungskompatibilität von Ausdrücken beachten, kommen implizite Typumwandlungen, anders als in C, praktisch nicht vor. Insbesondere bei der Übergabe von Daten (z. B. aus externen Dateien, aber auch innerhalb des Programms) an Funktionen oder Prozeduren kann der Compiler schon beim Kompilieren die Korrektheit der Typen kontrollieren.

Keine nullterminierten Zeichenketten

Standard Pascal hatte zwar Zeichenketten-Literale, aber keinen Typ string (s. oben). In den meisten späteren Implementierungen wurden Zeichenketten als char-Arrays definiert, bei denen das erste Feld (Byte) zur Speicherung der Länge verwendet wurde. Daraus ergab sich eine Längenbegrenzung von 255 Zeichen. Bei den in der C-Standard-Bibliothek verwendeten Strings handelt es sich dagegen um NUL-terminierte Strings. Durch die Längenspeicherung in Pascal können verschiedene Operationen wie Stringverkettung effizienter durchgeführt werden (kein Durchsuchen bis zum NUL-Zeichen erforderlich). Größere Zeichenketten mussten selbst definiert werden (z.  als Array of char), sofern sie nicht (wie z. B. in Borland Pascal 7) durch die Compilerhersteller bereits implementiert wurden. Im Extended-Pascal-Standard wurden Zeichenketten als Scheme-Typ definiert. Auch hier muss die Kapazität angegeben werden, sie wird aber in runde Klammern geschrieben, und es gibt keine formale Längenbeschränkung: String(10240).

Strikte Trennung zwischen Programm, Funktionen und Prozeduren

Pascal trennt strikt zwischen einer Funktion (mit Rückgabewert) und einer Prozedur (kein Rückgabewert). Eine Funktion darf nicht als Prozedur aufgerufen werden – d. h., der Rückgabewert muss stets entgegengenommen werden. Seit Turbo Pascal 4.0 (1987) ist es jedoch möglich, Funktionen auch ohne Entgegennahme des Funktionsergebnisses aufzurufen. Weiterhin wird ein ausführbares Programm in Pascal durch das Schlüsselwort PROGRAM gekennzeichnet, wohingegen in C der Einstiegspunkt für ein Programm die Funktion main ist, die sich außer durch ihren Namen nicht von anderen Funktionen unterscheidet.

Deklarationen

Programme, Funktionen und Prozeduren sind im Gegensatz zu C dreigegliedert: Es gibt neben dem Kopfteil, der den Namen und die Signatur enthält, einen separaten Deklarationsteil, in dem Typen, Variablen und verschachtelte Prozeduren/Funktionen deklariert werden und einen Definitionsteil, in dem implementiert wird. In C gibt es nur einen Funktionskopf und Funktionsrumpf, der den Deklarations- und Definitionsteil vereinigt. In C dürfen Funktionen nicht verschachtelt definiert werden.

Case sensitivity

Im Gegensatz zu C ist Pascal in Bezug auf Schlüsselwörter, Bezeichner von Variablen, Funktionen oder Prozeduren case-insensitive.

Semikolon

Das Semikolon wird nicht wie in C als Befehlsabschluss interpretiert, sondern als Trennzeichen zwischen Anweisungen. Vor einem END oder UNTIL kann es somit weggelassen werden. Vor einem ELSE darf es in der Regel gar nicht stehen, da sonst der IF-Zweig als abgeschlossen angesehen werden würde. Ein Fall, bei dem es vor dem ELSE steht (und stehen muss), ist am Ende einer CASE-Auflistung.

Delimiter

Für Zeichenketten-Literale und Zeichen-Literale wird dasselbe Begrenzungszeichen (Delimiter), nämlich der Apostroph, verwendet.

Zuweisungen

Zuweisungen an Variablen werden durch die Sequenz := definiert, das Gleichheitszeichen allein dient dem Gleichheitsvergleich und der Definition von Konstanten. Damit werden „mathematisch falsche“ Ausdrücke z. B. i = i + 1 vermieden. Verkürzte Schreibweisen für Zuweisungen wie i++ statt i := i + 1 oder i *= 2 statt i := 2 * i existieren in Pascal nicht.

Operatoren

Pascal verwendet die Operatoren and, or, not, div (nur für Integer, bei Real ist es /), mod und <> anstatt der C-Operatoren &&, || , !, /, % und !=. Die „Short Circuit“-Funktionalität von && und || in C (sobald das Ergebnis feststeht, nämlich wenn der linke Teil beim and FALSE beziehungsweise beim or TRUE ist, wird der rechte nicht mehr ausgewertet) schloss Niklaus Wirth explizit aus, da compilerinterne Optimierungsvorgänge die Reihenfolge der Auswertung verändern können. Spätere Pascalversionen implementierten eine lokal oder global zuschaltbare „Short Circuit“-Funktionalität, so dass der Programmierer im Einzelfall entscheiden kann, welche Art der Auswertung er wünscht. In Standard-Pascal gibt es keine Bitoperationen für Integer (wie &, |, ^ und ~ von C), aber stattdessen den Typ set of (mit den Operatoren *, + und - für Durchschnitt, Vereinigung und Mengendifferenz).

Strenge Typentrennung

Pascal betreibt strenge Typentrennung, sodass unter anderem der Typ Char nicht austauschbar ist mit Integer. Die Umwandlung muss mit den Funktionen ord() und chr() durchgeführt werden. Dadurch werden verdeckte (oder ungewollte) Umwandlungen vermieden; z. B. führt die Anweisung i := 7/2 (mit i als Integer) zu einer Fehlermeldung, weil der Operator / ein Operator ist, der Real als Ergebnis hat. Spätere Pascalversionen (z. B. Turbo Pascal) führten zusätzlich „explizite“ Typumwandlungen, sog. „type casts“, ein, so dass z. B. mit longint(i) der Wertebereich der Ganzzahlvariablen i erweitert oder eingeschränkt werden konnte. In Standard-Pascal musste dafür ein Umweg über (den Missbrauch von) Variantenrecords (union in C) genommen werden.

Zeigerarithmetik

In Pascal existiert keine Zeigerarithmetik, Iterationen über Arrays können nur über den Index erfolgen.

Standards

Wirths erste Veröffentlichung der neuen Programmiersprache erschien 1971, eine überarbeitete und erweiterte Version dieses Berichts 1973. Ein weiteres Jahr später folgte ein mit Kathleen Jensen geschriebener Bericht, den Wirth als ultimative Referenz für Programmierer und Implementoren bezeichnete; das darin beschriebene Pascal nannte er Standard Pascal.

Es gibt drei Standards, die sich auf Pascal beziehen:

1. Standard Pascal: ANSI/IEEE770X3.97-1993 oder ISO 7185:1990;
2. Extended Pascal: ANSI/IEEE770X3.160-1989 oder ISO/IEC 10206:1991;
3. sowie einen Entwurf zu „Object-Oriented Extensions to Pascal“.

Allerdings sind – wie bei den meisten anderen Programmiersprachen auch – nur die wenigsten Compiler zu diesen Standards vollständig kompatibel. Diese Tatsache verleitete Scott A. Moore zu der bissigen Bemerkung „Pascal is, unfortunately, very much a great improvement on its successors“ („Pascal ist leider so ziemlich eine große Verbesserung seiner Nachfolger“ – damals bereits ein geflügelter Satz).

Selbst großen Compilern wie Delphi oder Free Pascal fehlen bis heute einige Elemente aus Standard Pascal, während Extended Pascal von kaum einem unterstützt wird. Lediglich Prospero Pascal ist vollständig kompatibel zu Extended Pascal, während auch GNU Pascal vollständige Kompatibilität anstrebt.

Pascal und Mac OS

Historisch interessant ist die Tatsache, dass Apple bei der Entwicklung des Betriebssystems und der darauf laufenden Applikationen des Apple-II-Nachfolgers Macintosh auf Pascal gesetzt hatte. Hierzu wurde bei Apple in einem von Larry Tesler geführten Team unter Konsultation von Niklaus Wirth eine eigene Object-Pascal-Variante entwickelt, die von einer früheren objektorientierten Pascal-Variante namens Clascal abgeleitet wurde, die schon auf Lisa verfügbar war. Object Pascal war für die Unterstützung von MacApp, einem Macintosh Application Framework erforderlich, das heute unter den Begriff Klassen-Bibliothek fallen würde. Object Pascal wurde 1986 fertiggestellt. Apple beendete den Fokus auf Object Pascal mit der Umstellung von Motorola 68K-CPUs auf PowerPC-CPUs von IBM im Jahr 1994 mit der Betriebssystem-Version Mac OS 7.5. Zwecks Rückwärtskompatibilität blieb die Übergabe von Parametern für Betriebssystemaufrufe bis zur letzten Mac-OS-Version 9.2.2 des Jahres 2002 an Pascal-Konventionen angelehnt.

Implementierungen (Compiler, Interpreter und IDEs)

Pascal hatte von Anfang an im universitären Bereich sehr großen Erfolg, was sich u. a. auch in der Programmiersprache Ada niederschlug, die sehr stark an der Syntax von Pascal angelehnt ist. Ebenfalls fand es weite Verbreitung, auch im kommerziellen Bereich, mit den Produkten der Firma Borland Turbo Pascal, Borland Pascal und Delphi. Diese Versionen sind durch starke Erweiterungen des ursprünglichen Sprachstandards gekennzeichnet. Die Objektorientierung wurde dabei mit Version 5.5 eingeführt.

Freie Implementierungen

Integrierte Entwicklungsumgebungen

Geschichte

Pascal wurde nach dem französischen Mathematiker Blaise Pascal benannt. Die Entwicklung der Programmiersprache Algol (bis 1958) wie auch die ihrer Nachfolger war Produkt von Entwicklungskomitees. Niklaus Wirth war maßgeblich an der Erstellung des Abkömmlings Algol W beteiligt, das in Zürich entwickelt und 1966 fertiggestellt wurde. Er berichtete später von den Nachteilen einer gemeinsamen Entwicklung. Konsens innerhalb des Komitees musste mühsam erarbeitet werden, auch erschienen dem praktisch denkenden Wirth, der sich nicht nur als Wissenschaftler, sondern auch als Ingenieur sah, einige Entwicklungsziele mancher Kollegen als übertrieben und unumsetzbar.

Im Jahr 1968 erhielt Wirth eine Professur an der ETH Zürich, wo er neben seiner Lehrtätigkeit Zeit fand, mit der Entwicklung einer neuen Sprache zu beginnen. Er arbeitete diesmal alleine und konnte Pascal im Lauf des Jahres 1969 fertigstellen. Einer der Gründe für die Neuentwicklung war laut Wirth das Fehlen einer für den universitären Unterricht geeigneten Sprache. Weder das zu unwissenschaftlich angelegte Fortran noch das für die praktische Ingenieurstätigkeit ungeeignete Algol konnten Wirths Ansprüchen genügen. Über den Programmierunterricht hinaus sollte Pascal aber ebenso in der Wirtschaft, der Forschung und bei der Entwicklung von Compilern und Betriebssystemen einsetzbar sein.

CDC 6600

Nachdem Wirth die Sprache 1969 fertiggestellt hatte, folgte ein Jahr später die Entwicklung des ersten Pascal-Compilers. Dieser wurde für Computer der CDC 6000 Serie geschrieben und ging bereits 1970 in Betrieb. Im Jahr 1971 veröffentlichte Wirth die nur 28 Seiten lange Beschreibung der Sprache, 1972 konnten Lehrende Pascal erstmals für einführende Programmierkurse verwenden. 1973 folgte eine überarbeitete und 54 Seiten lange Überarbeitung der Spezifikation.

„Oft wurde ich gefragt, wie man eine Programmiersprache ‚erfindet‘. Man kann das nicht wirklich beantworten, aber es ist sicherlich eine Frage der Erfahrung auf dem Gebiet der Programmierung und von sorgfältiger Überlegung. Manchmal sage ich: ‚So, wie man ein Flugzeug entwickelt. Man muss eine gewisse Anzahl nötiger Bauelemente identifizieren und diese dann zu einem funktionierenden Ganzen zusammenbauen.‘ Diese Antwort ist vielleicht nicht voll zufriedenstellend, aber zumindest passiert dem Resultat in beiden Fällen dasselbe, entweder es fliegt oder es stürzt ab.“

– Niklaus Wirth

Kritik

Da die Sprache als Lehrsprache konzipiert war, wies das Standard-Pascal einige Merkmale auf, die den kommerziellen Einsatz erschwerten: Das Konzept für Dateizugriffe („file I/O“) war nicht mächtig, die Laufzeitbibliothek wenig umfangreich, und Zeichenketten konnten nur über Umwege (packed array) direkt im Code verwendet werden. Das führte dazu, dass praktisch jede kommerzielle Implementierung hierzu eigene Lösungen anbot, was zunächst (ähnlich wie die Diversifizierung bei C) zu eigenen Pascal-Dialekten und damit zu Kompatibilitätsproblemen führte. Mit der monopolartigen Dominanz der Turbo-Pascal-Produkte von Borland verschwanden diese Unterschiede fast vollständig.

Ein anderer wesentlicher Nachteil war, dass eine Modularisierung im Sinne getrennter Kompilierung nicht vorgesehen war – was mit der Weiterentwicklung Modula-2 geändert wurde. Plattformspezifische Implementierungen sahen dafür eigene Lösungen vor (z. B. die Units von Turbo-Pascal, fortgeführt in äquivalenten Unit-Implementierungen in Freepascal und Delphi, oder später die Module in ANSI/ISO Extended Pascal).

Weiterentwicklungen

• Pascal-XSC Pascal Dialekt mit „Language eXtensions for Scientific Computation“
• Oberon, Oberon-2
• POW! – basiert auf Oberon und Pascal
• Component Pascal – Weiterentwicklung von Oberon-2
• Embarcadero Delphi – Objektorientiertes Pascal als Weiterentwicklung von Borland Pascal.
• Free Pascal – eine zu Delphi weitgehend kompatible freie Implementierung. Dazu gibt es die Delphi ähnliche IDE Lazarus.
• RemObjects Chrome, Oxygene, nun lizenziert als Delphi Prism von CodeGear
• PocketStudio
• Pascal Script
• StatPascal
• Modula-2
• Concurrent Pascal – Pascal für nebenläufige Programme
• HP PPL, eine von HP entwickelte Pascal-Variante für Computeralgebra

Literatur

• Niklaus Wirth: The Programming Language Pascal. In: Acta Informatica. Volume 1, 1971, S. 35–63. (online)
• Niklaus Wirth: The Programming Language Pascal. Revised Report. Eidgenössische Technische Hochschule, Zürich 1973. (online)
• Niklaus Wirth: Algorithmen und Datenstrukturen. Stuttgart 1975, ISBN 3-519-02330-X.
• Niklaus Wirth: Pascal and its Successors. In: Manfred Broy, Ernst Denert (Hrsg.): Software Pioneers: Contributions to Software Engineering. Springer-Verlag, Berlin/ Heidelberg 2002, ISBN 3-540-43081-4, S. 108–119. (online)
• Kathleen Jensen, Niklaus Wirth: Pascal. User Manual and Report. (= Lecture notes in computer science. 18). Springer, Berlin 1974.
• Kathleen Jensen, Niklaus Wirth: Pascal User Manual and Report. ISO Pascal Standard. 4. Auflage. Springer-Verlag, 1991, ISBN 3-540-97649-3.
• Steven Pemberton, Martin Daniels, Ellis Horwood: Pascal Implementation: The P4 Compiler and Interpreter. ISBN 0-13-653031-1. (online)

Weblinks

Commons: Pascal (Programmiersprache) – Sammlung von Bildern, Videos und Audiodateien

Wikibooks: GNU-Pascal in Beispielen – Lern- und Lehrmaterialien

• UCSD-Pascal Source-Code (englisch)
• Brian W. Kernighan: Why Pascal is Not My Favorite Programming Language. AT&T Bell Laboratories, Murray Hill, New Jersey 1981. Ein Artikel, der ausführlich anhand von Beispielen auf die Nachteile von Pascal eingeht und Pascal mit anderen Programmiersprachen wie C oder Fortran vergleicht.

Einzelnachweise

1. Niklaus Wirth: The Programming Language Pascal. In: Acta Informatica. Band 1, 1971, S. 35–63, doi:10.1007/BF00264291.
2. M. Jordan: „Tag der Erfinder“ Heute: Niklaus Wirth. www.land-der-erfinder.ch, 15. Februar 2011, abgerufen am 21. Mai 2012. 
3. Andreas Schwill: Programmierstile im Anfangsunterricht. (PDF) Universität Paderborn, Fachbereich Mathematik/Informatik, abgerufen am 21. Mai 2012. 
4. Programmierstile im Anfangsunterricht. delphi-treff.de, abgerufen am 21. Mai 2012. 
5. Kathleen Jensen, Niklaus Wirth: Pascal. User Manual and Report. Springer, Berlin 1974.
6. Kathleen Jensen, Niklaus Wirth: Pascal. User Manual and Report. Springer, Berlin 1974, Vorwort
7. N. Wirth, C. A. R. Hoare: A Contribution to the development of ALGOL. In: Comm. ACM. 9, 6, Juni 1966, S. 413–432.
8. Niklaus Wirth: Pascal and its Successors. 2002, S. 108–119.
9. Niklaus Wirth: The Programming Language Pascal. 1971.
10. Niklaus Wirth: The Programming Language Pascal. Revised Report. 1973.
11. Niklaus Wirth: Pascal and its Successors. 2002, S. 108–119: Many times I have been asked how one "invents" a programming language. One cannot really tell, but it certainly is a matter of experience with the subject of programming, and of careful deliberation. Sometimes I answered: "Like one designs an airplane. One must identify a number of necessary building blocks and materials, and then assemble and combine them properly to a functioning whole". This answer may not be entirely satisfactory, but at least in both cases the result either flies or crashes.