Pascal
Paradigma	Imperatief
Verschenen	1970
Ontworpen door	Niklaus Wirth
Typesysteem	statisch, sterk
Implementaties	GNU Pascal, HP Pascal, Apple Pascal en andere
Dialecten	Borland Pascal, Turbo Pascal, Object Pascal en andere
Beïnvloed door	Algol
Invloed op	Modula-2, Ada, Oxygene, COMAL
Besturingssysteem	Multiplatform
Portaal    Informatica

Pascal is een programmeertaal die in 1970 ontwikkeld werd door Niklaus Wirth en die is genoemd naar de Franse wiskundige Blaise Pascal. In Pascal wordt de nadruk gelegd op eenvoud, gestructureerd programmeren en datastructuren. De taal was gebaseerd op de enkele jaren eerder ontwikkelde taal Algol-60 en een alternatief voor de te ingewikkelde opvolger daarvan (Algol-68).

Het was de bedoeling dat Pascalprogramma's op een minicomputer konden worden gecompileerd en uitgevoerd. In feite had Wirth al een soort personal computer voor ogen. Pascal is echter voor praktische toepassingen nooit zo populair geworden als de programmeertaal C van Brian Kernighan en Dennis Ritchie, die dezelfde structuren biedt als Pascal, maar daarnaast ook meer mogelijkheden om ze te kunnen omzeilen en mogelijkheden om optimalisaties voor de te gebruiken computer uit te kunnen voeren, zaken die Wirth juist wilde vermijden, maar waar programmeurs wel behoefte aan hadden.

In de jaren 1970 sloeg Pascal nog niet zo aan. Enerzijds waren de minicomputers nog te duur om stand-alone gebruikt te worden, anderzijds bleven mainframegebruikers aan talen als Algol-60 en Fortran vasthouden. Dat veranderde in de jaren 1980, toen compilers voor verschillende varianten voor personal computers beschikbaar kwamen. Pascal verving toen Algol-60 als de meest gebruikte taal voor het programmeeronderwijs aan universiteiten en hogescholen. Na het gestructureerd programmeren, waarvan Edsger Dijkstra de grote voorvechter was, werd de volgende grote ontwikkeling het objectgeoriënteerd programmeren; zowel van C als van Pascal zijn later objectgeoriënteerde varianten gemaakt. Turbo Pascal was een populaire variant.

Pascal is, in zijn oorspronkelijke vorm, een puur procedurele taal.

Een veel gebruikt voorbeeld om een indruk te krijgen van de grammatica van een taal is het "Hello world" programma.

 program helloworld(output);
 begin
   writeln('Hello world!')
 end.

In Pascal zijn sleutelwoorden niet hoofdlettergevoelig. Verder hebben (buiten strings) spaties voor en na een puntkomma en de punt en extra spaties, geen invloed. Ook is een overgang naar een nieuwe regel gelijkwaardig aan een spatie.

Een Pascalprogramma start met het sleutelwoord "program", gevolgd door een identifier met eventueel tussen haakjes een of meer parameters en dan een puntkomma. Sommige compilers staan toe het tot hier genoemde weg te laten. Vervolgens volgt eventueel een uses clause. De rest is een blok, gevolgd door een punt.

Het blok bestaat uit een declaratiedeel (hierboven leeg) en een samengestelde opdracht, dat bestaat uit "begin", nul of meer opdrachten gescheiden door puntkomma's en "end". Een opdracht mag ook leeg zijn, daarom is ook een puntkomma vóór "end" toegestaan.

Het declaratiedeel kan onder meer bestaan uit de declaratie van een of meer variabelen, zoals:

var m,n:integer; a,b,c:real; f:textfile

Een opdracht (o) kan onder meer zijn (met (oo) staand voor nul of meer opdrachten gescheiden door puntkomma's en (e) voor expressie):

• een toekenningsopdracht zoals n:=n+1
• een gestructureerde opdracht:
  • een samengestelde opdracht (zie boven)
  • een voorwaardelijke opdracht:
    • if (e) then (o)
    • if (e) then (o) else (o)
  • een herhalingsopdracht zoals:
    • for n:=1 to 10 do (o)
    • for n:=10 downto 1 do (o)
    • repeat (oo) until (e)
    • while (e) do (o)

Expressies zijn bijvoorbeeld "m=10", "m<n" en combinaties zoals "(m=10) and (m<n)" en "(m=10) or (m<n)".

Schrijven naar een bestand met bestandslocatie (b) kan (afhankelijk van de compiler) bijvoorbeeld als in het volgende voorbeeld:

var d: integer;
    f: textfile;
begin
assignfile(f,(b));
  try
    rewrite(f);
    for d:=1 to 10 do writeln(f,d,' ',d*d);
  finally
    closefile(f)
  end
end.

De functie "write" in plaats van "writeln" wordt gebruikt als er nog meer op dezelfde regel moet komen.

Pascal is duidelijk gebaseerd op Algol-60 en het is dus zinvol de verschillen met die taal en de redenen voor die verschillen te beschrijven. In de meeste gevallen zijn de vernieuwingen in Pascal ook in latere talen overgenomen. Er zijn drie soorten verschillen:

1. Syntactische verschillen
2. Beperkingen
3. Uitbreidingen

• De basissymbolen zijn gereserveerde woorden, die op dezelfde wijze weergegeven worden als andere woorden. Een identifier kan dus niet de naam begin of if hebben. In Algol-60 moeten de basissymbolen zich op een door de compiler voorgeschreven wijze onderscheiden van andere woorden. In Algol-60 is begin een geldige identifier, en wordt het vergelijkbare basissymbool anders geschreven, bv. als begin, 'BEGIN' of begin.
• Declaraties staan vóór de bijbehorende begin.
• De parameters van procedures (subprogramma's) worden op een andere manier gedefinieerd.
• Commentaar staat tussen accolades en niet achter comment.
• Een functie (subprogramma dat een waarde oplevert) wordt als function gedefinieerd en niet als real procedure of integer procedure.

• Declaraties komen alleen voor aan het begin van programma en procedures en niet in blokken die midden in het programma kunnen staan. Dit dwingt de programmeur ertoe het programma uit procedures en functies op te bouwen.
• De grenzen van arrays moeten constanten zijn. Dit vereenvoudigt de implementatie.
• Formele parameters van procedures kunnen alleen by-value en by-reference aangeroepen worden. De call-by-name, het gebruik van procedures als parameter en het Jensen device vervallen. Dit vereenvoudigt de implementatie.
• De ownvariabele vervalt. Deze werd weinig gebruikt en was lastig te implementeren.
• De switch vervalt. De functie wordt overgenomen door case.

• Constanten kunnen een naam krijgen. Daarmee wordt gedeeltelijk voorzien in de behoefte aan arrays met variabele grenzen.
• De datatypes char, record, set (verzameling) en file zijn toegevoegd. Daarmee wordt het toepassingsgebied uitgebreid.
• Nieuwe datatypes kunnen in het programma gedefinieerd worden. Dit is vooral van belang bij het gebruik als parameter.
• Het datatype pointer is toegevoegd. Hiermee kunnen echt dynamische datastructuren als lijsten en bomen worden gedefinieerd.
• Met het casestatement kan een keuze uit verschillende mogelijkheden gemaakt worden.

Pascal is rond dezelfde tijd ontwikkeld als C en er zijn veel overeenkomsten tussen beide talen. Het oorspronkelijke Pascal en C zijn beide simpele procedurele talen waarin gestructureerd kan worden geprogrammeerd. Ze hebben voorzieningen voor dynamisch geheugenbeheer en pointermanipulatie. Uiterlijk echter zijn de talen totaal verschillend, waarbij C veel compacter, maar minder "leesbaar" is.

Een belangrijk verschil dat een bron is van voorkeur voor de ene of de andere taal, is het gebruik in Pascal van := als toewijzigingsoperator, en = voor vergelijkingen. In C wordt = als toewijzigingsoperator gebruikt, en == voor vergelijkingen. Omdat = in de wiskunde voor beide doeleinden wordt gebruikt, gebruiken velen het kortere symbool wanneer het andere symbool (hetzij := in Pascal dan wel == in C) bedoeld wordt. De ontwerpers van C argumenteerden dat toewijzingen veel vaker voorkwamen dan vergelijkingen, en dat dus de toewijzing het kortste symbool verdiende. Aanhangers van Pascal brengen daar tegenin dat het per ongeluk uitvoeren van een vergelijking veel minder schadelijk is dan van een toewijzing, hetgeen zeker waar is als, zoals in C, het volkomen correct is een toewijzing midden in een if-statement uit te voeren. Moderne compilers maken de programmeur op dit soort zaken attent, waarmee de grond voor discussie grotendeels is vervallen.

Het grootste risico van het gebruik van C t.o.v. Pascal is verwarring rondom pointers. In productie-omgevingen worden relatief veel zeer lastig te vinden fouten in C-programma's gemaakt door het per abuis verwisselen van een adres van een pointer met de waarde waarnaar de pointer wijst. In Pascal is een dergelijke verwisseling dankzij de sterke type-checking onmogelijk.

Dit debat is een illustratie van de verschillen die aan het ontwerp van beide talen ten grondslag lagen. Pascal was gedeeltelijk ontworpen als studietaal. Foutgevoelige constructies werden bewust vermeden en er werd veel zorg besteed aan het eenvoudig leesbaar maken van de code. De ontwerpers van C legden daarentegen de nadruk op kort-en-bondigheid.

Een ander belangrijk verschil is dat Pascal sterke typering heeft. Dit betekent dat alle variabelen vooraf al van een bepaald type gedefinieerd moeten zijn voordat zij gebruikt kunnen worden. Toewijzingen tussen niet-uitwisselbare typen zijn verboden en geven een compilerfout, tenzij ze door een expliciete typecast geconverteerd worden. Dit voorkomt veelgemaakte fouten waar variabelen niet correct gebruikt worden doordat de programmeur niet in het oog had gehouden wat het type van de variabelen was. Er is ook geen noodzaak meer voor Hongaarse notatie, een gewoonte waarbij identifiers beginnen met een letter die het type identificeert.

In tegenstelling tot C is het in Pascal mogelijk procedures meervoudig te nesten. Geneste functies hebben daarbij volledige toegang tot variabelen en parameters van de functie waar ze genest zijn. Oorspronkelijk had Pascal geen mechanismen voor gescheiden compilatie en de afhandeling van arrays van onbekende grootte; er zijn echter al tientallen jaren implementaties beschikbaar die deze functionaliteit wel bieden.

Vroege implementaties (met name de UCSD p-System-compiler, die gebaseerd was op de Zürich-P4-compiler, beide geschreven in Pascal zelf) vertaalden Pascalcode in een machineonafhankelijke P-Coderepresentatie. Deze tussenvorm werd vervolgens geïnterpreteerd door een programma dat specifiek was voor een computerarchitectuur. Het gevolg was dat alleen deze compacte interpreter aan de verschillende architecturen aangepast diende te worden.

In de jaren tachtig schreef Anders Hejlsberg de Blue Label Pascalcompiler voor de Nascom-2-computer. Hejlsberg ging later voor het bedrijf Borland werken en herschreef zijn compiler tot wat Turbo Pascal voor de IBM-pc zou worden. Deze nieuwe compiler lag voor 49 dollar in de winkel, veel minder dan de prijs die Hejlsberg oorspronkelijk vroeg voor de Blue Label-compiler.

De goedkope compiler van Borland heeft veel invloed gehad op de Pascalgemeenschap, die zich eind jaren tachtig hoofdzakelijk op de IBM-pc begon te concentreren. Veel pc-hobbyisten zochten een gestructureerde programmeertaal die BASIC kon vervangen en kwamen veelal bij Turbo Pascal terecht. Turbo Pascal vertaalde rechtstreeks naar de machinetaal van de Zilog Z80 of de Intel 8086, de enige architecturen die het ondersteunde en was daardoor veel sneller dan geïnterpreteerde systemen.

Super Pascal was een variant die niet-numerieke labels, een returnstatement en expressies als typenamen toevoegde.

In de jaren negentig werden compilers die flexibel op meerdere computerarchitecturen toegepast konden worden, dominanter. Dit maakte het mogelijk Pascal direct naar machinetaal te vertalen en tegelijk eenvoudig aan andere hardware aan te passen.

Met de introductie van versie 5.5 voegde Borland objectgeoriënteerd programmeren aan Pascal toe. Later echter besloot Borland dat het uitvoeriger objectgeoriënteerde mogelijkheden wilde en begon opnieuw in Delphi, waarbij men de kladstandaard Object Pascal, die door Apple was voorgesteld, implementeerde. (Object Pascal is overigens nooit een formele standaard geworden.) In de eerste versies van Delphi werd de geïmplementeerde taal nog gewoon Object Pascal genoemd, maar in latere versies werd hij hernoemd naar "programmeertaal Delphi". De belangrijkste wijzigingen met betrekking tot de oudere objectgeoriënteerde extensies waren een op referentie gebaseerd objectmodel en virtuele constructors, destructors en eigenschappen. Er zijn verscheidene compilers die dit dialect implementeren. De Linuxversie van Delphi en daarmee ook Pascal, is beschikbaar als Kylix.

Er zijn veel verschillende Pascalcompilers beschikbaar:

• De P4-compiler, de basis voor veel in Pascal geïmplementeerde Pascalcompilers, inclusief het UCSD p-System. In 2003 werd de site voor het laatst aangepast, de laatste versie waarschijnlijk vroege jaren negentig.
• Free Pascal is geschreven in Pascal (zodat het zichzelf kan compileren), en mikt op het aanbieden van een gemakkelijke en krachtige compiler welke in staat is bestaande programma's te compileren, en heeft moderne aantrekkelijke functies om er nieuwe software in te schrijven. Wordt vrijelijk beschikbaar gesteld onder de GNU GPL-licentie. Het kan Turbo Pascalcode combineren met Delphicode en ondersteunt veel platforms en ook wat minder bekende (o.a. Apple) dialecten. Compiler versie 2.6.4, voorjaar 2014; versie 3.2.2, voorjaar 2021.
• Lazarus (software), een open Rapid Application Development (RAD) omgeving, met Free Pascal als compiler. Lazarus+Free Pascal zijn ruwweg opgezet als een substituut voor Delphi, met vele componenten. Versie 1.2.4, voorjaar 2014; versie 2.0.4, augustus 2019; versie 3.4, voorjaar 2024.
• Turbo Pascal was de dominante Pascalcompiler voor pc's gedurende de jaren tachtig en begin jaren negentig, vooral dankzij de krachtige taaluitbreidingen en snelle compilatie. Tegenwoordig zijn oudere versies van Turbo Pascal (tot en met 5.5) gratis te downloaden vanaf Borlands website (registratie verplicht), v7: 1994.
• De GNU Pascal Compiler (GPC) is een aanvulling op de GNU Compiler Collection (GCC) en is geschreven in C. Hij wordt vrijelijk beschikbaar gesteld onder de GNU General Public License. De ondersteuning van Borland/Turbo Pascal is daarentegen aan de beperkte kant. Augustus 2006, GNU Pascal lijkt gestopt te zijn met formele releases, maar sporadisch worden er wel nieuwe patches/source archives beschikbaar gesteld. In 2011 is de systematische ontwikkeling gestaakt. Er is nog wel support.
• Delphi is het vlaggenschip van Borland. Dit RAD-product gebruikt de programmeertaal Delphi, afgeleid van Pascal, en dient om programma's voor het Windowsplatform te schrijven. De recentste versie kan ook compileren voor het .NET-platform. Delphi XE6, Voorjaar 2014
• Kylix is Borlands nieuwste telg in de Pascal-familie. Het is een variant van Delphi met ondersteuning voor het besturingssysteem Linux en een verbeterde objectbibliotheek. De compiler en ontwikkelomgeving zijn tegenwoordig gratis te downloaden van de website van Borland. Delen van Kylix zouden oorspronkelijk open source worden, maar tot op heden is dit niet gebeurd. Recentelijk is hier de reden voor bekend geworden: Embarcadero recyclet de Kylix-onderdelen voor zijn crosscompilinguitbreidingen in Delphi 2011. Kylix : 2003, huidige Delphi XE6 (2014): geen Linux support.
• Prospero Extended Pascal 32-bit Extended Pascal compiler en linker voor PC Windows omgeving. Augustus 2006.

Hoewel erg populair (maar dan meer in de jaren tachtig en begin jaren negentig), werden vroege versies van Pascal breed bekritiseerd omdat zij ongeschikt zouden zijn om serieuze programma's mee te schrijven. Brian Kernighan, mede-auteur van de programmeertaal C, zette al in 1981 sterke bezwaren uiteen in zijn rapport.^[1] Aan de andere kant werden enkele grote ontwikkelprojecten in de late jaren zeventig en vroege jaren tachtig, zoals voor de Apple Lisa en Apple Macintosh, in Pascal geschreven. Dit doordat bij de in de praktijk gebruikte dialecten alle problemen die Kernighan aanstipt al opgelost waren. In de decennia daarna is Pascal blijven doorevolueren en de meeste bezwaren zijn niet meer van toepassing op de huidige implementaties.

Het op Pascal gebaseerde Delphi is nog altijd de op een na (na Visual Studio) meest verkochte ontwikkelomgeving ter wereld.

• Pascal: User manual and report, Kathleen Jensen and Niklaus Wirth, Springer Verlag 1974, 1985, 1991, ISBN 0-387-97649-3, ISBN 3-540-97649-3
• Wirth,N. Algorithms+Data Structures=Programs, Prentice Hall, Englewood Cliffs N.J. , 1976.

Wikibooks heeft meer over dit onderwerp: Cursus programmeren in Pascal.