Pascal (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Pascal
Paradigmen: imperativ, strukturiert
Erscheinungsjahr: 1971
Entwickler: Niklaus Wirth
Typisierung: stark, statisch
Dialekte: UCSD-Pascal, Borland Turbo Pascal
Beeinflusst von: ALGOL
Beeinflusste: Modula-2, Ada, Oberon, Object Pascal, Web
Niklaus Wirth, der Entwickler von Pascal

Die Programmiersprache Pascal (benannt nach dem Mathematiker Blaise Pascal) wurde von Niklaus Wirth an der ETH Zürich im Jahr 1971 als Lehrsprache eingeführt, um die strukturierte Programmierung zu lehren.[1]

Allgemeines zur Sprache[Bearbeiten]

Pascal ist eine Weiterentwicklung von Algol 60. Es lehnt sich in seiner Syntax stark an die englische Grammatik an. Dies soll die Lesbarkeit für Programmiereinsteiger verbessern und macht es daher besonders als Lehrsprache geeignet. Seine große Verbreitung in der professionellen Programmierung fand es als Borland/Turbo Pascal (später Object Pascal) – gegenüber dem Ur-Pascal wesentlich erweiterte und verbesserte Versionen.

Ein wichtiges Konzept, das Wirth zur Anwendung brachte, ist die starke Typisierung (engl. „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 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 ist die 2005 eingeführte Betriebsleittechnik IV der Transrapid-Versuchsanlage Emsland in Pascal programmiert. Eine pascalähnliche Notation wird von jeher in der Informatik und Mathematik zur Darstellung von Algorithmen benutzt.[2] Aus didaktischen Gründen, es seien hier die Typstrenge, hohe Fehlersicherheit und frei verfügbare portierbare Pascalcompiler (Free Pascal, GNU Pascal) genannt, wird im aktuellen Informatikunterricht Pascal ebenfalls häufig eingesetzt.[3] Im Hobby-Bereich erlangte Pascal zeitweilig eine sehr weite Verbreitung, die jedoch mit neueren Microsoft-Windows-Versionen wieder zurückging.[4]

Datentypen[Bearbeiten]

Ein Datentyp gibt an, welche Werte eine Variable annehmen kann und welche Operationen auf ihr verwendet werden können. Die einfachen Datentypen in Pascal sind:

Datentyp Werte, die Variablen diesen Types speichern können
integer Ganze Zahlen
real Gleitkommazahlen
boolean die Werte true und false
char ein einzelnes Zeichen

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

Aus den einfachen ordinalen Datentypen (alle außer real) können Typen abgeleitet werden, die Teilmengen dieser Datentypen darstellen. Beispiel:

type byte = 0..255; // Variablen des Types "byte" können nun die Ganzen Zahlen von 0 bis 255 als Wert annehmen,
                     // was eine Teilmenge von Integer ist.

Weiterhin können die Datenstrukturen array und set (Menge) verwendet werden.

Zeiger können in Pascal ebenfalls verwendet werden. Es existiert jedoch keine Zeigerarithmetik.

Programmstrukturen[Bearbeiten]

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[Bearbeiten]

Für Verzweigungen können in Pascal if-else und case verwendet werden. Für Schleifen existiert while, repeat-until und for. Sprunganweisungen können mit goto auch verwendet werden, dessen Gebrauch jedoch umstritten ist (siehe Artikel zu Sprunganweisungen).

Compiler[Bearbeiten]

Der erste Pascal-Compiler selbst 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.

Bei den meisten Pascal-Compilern handelte es sich um Single-Pass-Compiler, d. h. der Compiler muss die Quelle nur ein einziges Mal lesen und analysieren. Das Design der Sprache war so gehalten, um genau das zu ermöglichen. Bei der damaligen geringen Geschwindigkeit der Rechner war dies ein großer Vorteil.

Unterschiede zu C[Bearbeiten]

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 Compilieren 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 strings als char-Arrays definiert, bei denen das erste Feld zur Speicherung der Länge verwendet wurde, woher allerdings ein Zeichenlimit von 255 Zeichen herrührt. Bei den in der C-Standard-Bibliothek verwendeten Strings handelt es sich um null-terminierte Strings. Durch die Längenspeicherung in Pascal können jedoch verschiedene Operationen wie Stringverkettung effizienter durchgeführt werden (kein Durchsuchen bis zum null-Zeichen erforderlich). Größere Zeichenketten mussten selbst definiert werden (z. B. 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 (Rückgabewert) und einer Prozedur (kein Rückgabewert, Typ void in C). Eine Funktion darf nicht als Prozedur aufgerufen werden – d. h. der Rückgabewert muss stets entgegengenommen werden. Seit Turbo Pascal 4.0 (1991) ist dies jedoch möglich: Funktionen können auch ohne Entgegennahme des Funktionsergebnisses aufgerufen werden. 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 Funktionskörper, der den Deklarations- und Definitionsteil vereinigt. In C dürfen Funktionen nicht verschachtelt definiert werden.
Case sensitivity
Im Gegensatz zu C ist Pascal weder im Bezug auf Schlüsselwörter, noch Bezeichner von Variablen, Funktionen oder Prozeduren case sensitive.
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 Vergleich 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
U. a. ist Char nicht austauschbar 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 zu einer Fehlermeldung, wenn i vom Typ Integer = Ganzzahl ist da 7/2 = 3.5 keine Ganzzahl ist. 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.

Standards[Bearbeiten]

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[Bearbeiten]

Historisch interessant ist die Tatsache, dass Apple bei der Entwicklung des Betriebssystems und der darauf laufen 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, welche 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 Jahre 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)[Bearbeiten]

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.

Heute gibt es einige freie Implementationen:

Free Pascal
Ein unter der GNU Lesser General Public License stehendes Open-Source-Projekt, das sich zum Ziel gesetzt hat, einen freien 32/64-Bit-Compiler zu erzeugen, der 100-prozentig kompatibel zu Turbo Pascal und Delphi sein soll und mittlerweile eine leichte Portierung von Pascal-Programmen auf fast alle gängigen Betriebssysteme und Hardwareplattformen ermöglicht.
GNU Pascal (GPC)
Ein Pascal-Compiler, der als Frontend zur GNU Compiler Collection konzipiert ist. Er ist kein Bestandteil der GCC selbst, ist aber durch die Verwendung der GCC plattformunabhängig. GPC wird nicht mehr weiterentwickelt.
Virtual Pascal
Diese inzwischen freie Implementierung eines Borland-kompatiblen Pascal-Compilers für OS/2 wurde auch auf andere Plattformen portiert, wird aber seit 2005 nicht mehr weiterentwickelt.

Integrierte Entwicklungsumgebungen:

Lazarus
Eine Entwicklungsumgebung für Free Pascal, die auch verschiedene Komponenten zur Verfügung stellt. Die IDE ist sehr Delphi-ähnlich gestaltet und verwendet unter Unix das GTK+ als Grafik-Toolkit, unter Windows (win32/win64/wince) setzt es auf der nativen API auf, und auf Apple-Betriebssystemen kann wahlweise die native Carbon-API oder das X-Window-System verwendet werden. Darüber hinaus unterstützt Lazarus Cross Compiling, so dass auch Software für weitere Plattformen wie Windows CE, OS/2, Palm OS oder Nintendo DS entwickelt werden kann.
Dev-Pascal
Eine unter Windows laufende IDE, die auf Free-Pascal oder GNU-Pascal als Compiler aufsetzen kann. Sie wird nicht mehr weiterentwickelt.

Hallo Welt[Bearbeiten]

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

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

oder 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 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.

Kritik[Bearbeiten]

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 Compilierung 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, oder später die Module in ANSI/ISO Extended Pascal).

Weiterentwicklungen[Bearbeiten]

Literatur[Bearbeiten]

Weblinks[Bearbeiten]

 Commons: Pascal (Programmiersprache) – Sammlung von Bildern, Videos und Audiodateien
 Wikibooks: GNU-Pascal in Beispielen – Lern- und Lehrmaterialien

Einzelnachweise[Bearbeiten]

  1. Niklaus Wirth: The Programming Language Pascal, 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.