Pascal (programmeringsspråk)

**Pascal** er et programmeringsspråk skapt av informatikeren Niklaus Wirth. 1972 innførte han språket ved ETH Zürich for at studentene skulle lære å omgås med strukturert programmering.

## Historie
Pascal er basert på programmeringsspråket Algol 60 og ble navngitt for å ære den franske matematikeren og filosofen Blaise Pascal. Etter Pascal utviklet Wirth Modula-2 og Oberon, språk som ligner Pascal.

Til å begynne med var Pascal til stor grad påtenkt som et pedagogisk utformet språk for å lære studenter strukturert programmering. Generasjoner av laveregradsstudenter har fått bryne seg på Pascal. Varianter av Pascal har ofte blitt brukt til alt fra forskningsprosjekter til videospill og innebygde  systemer. Nyere Pascal-kompilatorer eksisterer og brukes vidt og bredt.

Pascal var det primære høynivåspråket for utviklingen av Apples datamaskin Lisa, og de første årene Apple utviklet Mac. Deler av det opprinnelige operativsystemet for Macintosh ble oversatt for hånd til Motorola 68000 maskinkode fra kilden i Pascal. Det populære settesystemet TeX av Donald Knuth var skrevet i WEB, et litterært programmeringssystem basert på DEC PDP-10 Pascal. Programmet Total Commander var skrevet i Delphi, dvs. Object Pascal.

## Kort beskrivelse
Wirth hadde til hensikt å skape et effektivt språk (både med hensyn til kompileringshastighet og generert kode) basert på såkalt strukturert programmering, et konsept som på den tiden hadde blitt populært. Pascal har sine røtter i Algol 60, men introduserte konsepter og mekanismer (på toppen av Algols skalarer og tabeller) som gjorde det mulig for programmerere å definere deres egne komplekse (strukturerte) datatyper. Dette gjorde det lettere å bygge dynamiske og rekursive datastrukturer som lister, trær og grafer. Viktige egenskaper inkludert for dette var *records* (poster), *enumerasjoner*, «underrekker» (eng:subranges) og *dynamisk* allokerte variabler assosiert med *pekere* og samlinger (eng:sets). For å gjøre dette mulig og meningsfullt krever Pascal at en type data ikke kan konverteres eller tolkes uten å bruke eksplisitte konverteringsmekanismer (eng: strong typing). Lignende funksjoner er standard i mange av dagens programmeringsspråk. Andre språk som påvirket Pascals utvikling var COBOL, Algol 68, Simula og Wirths eget Algol-W.

Pascal, som mange andre skriptspråk i dag (men ulikt de fleste språkene i C-familien) tillater innkapslede funksjoner til en hvilken som helst dybde. Pascal tillater også de fleste definisjoner og deklarasjoner inni prosedyrer og funksjoner. Dette muliggjør en veldig enkel og konsekvent syntaks der et komplett **program** som syntax er nesten identisk med en enkelt **prosedyre** eller **funksjon** (bortsatt fra nøkkelordet selv).

## Språkets oppbygning
Pascal i sin opprinnelige form er et fullstendig prosedyremessig språk og inkluderer en rekke Algol-aktige kontrollstrukturer med reserverte ord som **if**, **then**, **else**, **while**, **for**, osv. Likevel har Pascal også mange fasiliteter for datastrukturering og andre abstraksjoner som ikke ble med i Algol 60 som type-definisjoner, records, pekere, enumererte typer og sett. Slike konstruksjoner ble tildels arvet eller inspirert av Simula, Algol 68, Niklaus Wirths egen Algol-W og forslag fra C. A. R. Hoare.

Pascal-programmer begynner med nøkkelordet **program**, med en liste av eksterne fil-deskriptorer som parametre. Så følger hovedblokken som rammes inn av **begin** og **end**. Semikolon separerer enkelte setninger, og punktum avslutter hele programmet. Pascal skiller ikke mellom store og små bokstaver. Noen kompilatorer bl.a. Turbo Pascal gjør **program** nøkkelordet valgfritt.

### Hello World

```pascal
program Hello(output);
    begin
        WriteLn('Hello, world!')
    end.
```


### Datastrukturer
Pascals *enkle* udelelige typer er *real* (desimaltall), *integer* (heltall), *character* (tegn), *boolean* og enumerasjoner (opptellinger) definert ved eksplisitte lister av mulige verdier:

```pascal
var
  r: Real;
  i: Integer;
  c: Char;
  b: Boolean;
  e: (eple, paere, banan, appelsin, sitron); //En enumerasjon
```


En av nyskapingene i Pascal er at programmeringsspråket støtter en sett-type:


```pascal
var
  tall : set of 1..10;
  bokstaver : set of 'a'..'z';
  frukt : set of eple..appelsin;
```


Et sett (eller samling) er et fundamentalt konsept innen moderne matematikk. Sett brukes i mange algoritmer. En slik språkkonstruksjon er nyttig og kan være raskere enn en ekvivalent løsning i et språk som ikke støtter sett. Mange Pascal-kompilatorer skaper mer optimal og effektiv maskinkode av dette:

```pascal
if i in [5..10] then
...
```


enn av:


```pascal
if (i>4) and (i<11) then
...
```


Nye typer kan defineres ut fra allerede eksisterende typer ved bruk av type-deklarasjoner:


```pascal
type
  x = Integer;
  y = x;
...
```


Videre kan sammensatte typer skapes av enklere typer:


```pascal
type 
  a = Array [1..10] of Integer;
  b = record
        x: Integer;
        y: Char
      end;
  c = File of a;
```


Som vist ovenfor er Pascal-filer sekvenser av komponenter. Hver fil har en buffervariabel annotert av *f^*. Funksjonene *get* (for lesing) og *put* (for skriving) flytter buffervariabelen til det neste elementet. Lesing er slik at *read(f, x)* er det samme som *x:=f^; get(f);*. Skriving er slik at *write(f, x)* er det samme som *f^ := x; put(f);* Datatypen *text* er på forhånd definert som en fil med *char*-verdier. Buffervariabelen kunne ha vært brukt til å sjekke det neste tegnet. F.eks. sjekke om neste tegn faktisk er et tall før et heltall lagres. Dette konseptet førte til alvorlige problemer i interaktive programmer i tidlige implementasjoner, men ble løst senere med «lat I/O» (eng:lazy I/O).

I «Jensen & Wirth» Pascal (den offisielle originalversjonen) er strenger representert av pakkede tabeller med tegn (char), de har derfor en bestemt lengde og er vanligvis fylt med mellomrom der det ikke skal være tekst. Noen Pascal-dialekter bruker en egen strengtype.

#### Pekere
Pascal støtter bruk av pekere:


```pascal
type 
  a = ^b;
  b = record
        x: Integer;
        y: Char;
        z: a
      end;
var
  peker_til_b: a;
```


Her er variabelen *peker_til_b* en peker til datatypen *b* som er en *record*. Pekere kan brukes før de deklareres. Dette er et unntak til regelen om at programkomponenter skal deklareres før bruk. For å skape en ny *record* og tilordne verdien *10* og tegnet *A* til feltene *a* og *b* i vil kommandoene være:


```pascal
new(peker_til_b);
```



```pascal
ppeker_til_b^.x := 10;
ppeker_til_b^.y := 'A';
peker_til_b^.z := nil;
...
```


Dette kunne også ha vært gjort med **with**, slik


```pascal
new(peker_til_b);

with peker_til_b^ do
begin
  x := 10;
  y := 'A';
  z := nil
end;
...
```


Innenfor definisjonsområdet (eng: scope) til **with** vet kompilatoren at a og b refererer til underfeltene til record-pekeren **peker_til_b** og ikke til «record»-en b eller pekertypen a.

Lenke-, stakk- og køstrukturer kan skapes ved å inkludere en peker-egenskap (eng:field) (c) i "record"-en.

## Eksempel på Pascal-kode

```pascal
program Alder;//Programmets navn

    uses//Indikerer at man skal liste opp biblioteker
        Crt;//Standard bibliotek for skriving til konsoll
    
    var//Indikerer at det kommer noen variabler
      a: byte;//variabel
       
    begin
        writeln('Hvor gammel er du?');//skriver ut på skjermen ''Hvor gammel er du?''
        readln(a);//Leser inn svaret inn i variabel a
        
        writeln;//Lager en ny linje i Console vinduet
 
        if a > 100 then//sjekker om variabel a er større enn 100
           write('Du er jammen gammel.')//Hvis den er det skriver den ''Du er jammen gammel.'' på skjermen
        else//Hvis ikke
           write('Rene ungdommen.');//Skriver ''Rene ungdommen.'' på skjermen
        
        readln;//Venter til brukeren trykker enter
    end.//avslutter programmet. Og frigjør variabler fra minnet
```


## Eksterne lenker
* 
*  www.freepascal.org  Free Pascal er en kompilator skrevet i Pascal (kompilerer seg selv) for flere plattformer. Den er distribuert under GNU GPL. 
*  smartmobilestudio.com Smart Mobile Studio har en kompilator som kompilerer Object Pascal (Smart Pascal) til Java Script. Verktøyet er utviklet av norske Optimale Systemer AS.