Pascal (programski jezik)

**Pascal** je programski jezik nastao na ETH Zürich institutu 1970. godine. Dizajnirao ga je Niklaus Wirth, švicarski računalni znanstvenik, i nazvao prema francuskom filozofu, fizičaru i matematičaru, Blaiseu Pascalu, koji je 1641. izumio mehanički kalkulator.

Pascal je imperativni programski jezik, prvobitno s proceduralnim, i nekim funkcijskim mogućnostima, a kasnije je preko svojih varijanata i *dijalekata* evoluirao u jezik koji podržava objektno-orijentirano programiranje. Svojevremeno je smišljen s namjerom da omogući i popularizira strukturirano programiranje, koje je u doba dominacije Fortrana bilo relativno nepopularna programska paradigma. Nastao je po uzoru na Algol, najstariji strukturirani programski jezik, kao neizravna posljedica i "kolateralna korist" pokušaja da se *Algol 60* varijanta izmijeni i poboljša.

## Nastanak i razvoj Pascala

*Niklaus Wirth* je bio član *Radne skupine 2.1* (*Working Group 2.1*), koja je od 1963. radila na izmjeni jezika *Algol 60*, s ciljem da se razvije i standardizira njegova nova i naprednija varijanta. Unutar *WG-2.1* došlo je do podjele na dvije frakcije: "teoretičari" (*Algol Y* grupa) su zahtijevali snažan programski jezik s ogromnim brojem mogućnosti, dok su "praktičari" (*Algol X* grupa), s izkustvom u implementaciji programskih jezika, imali stoga umjerenije, minimalističke ambicije. Wirth je, kao "praktičar", 1965. godine predstavio svoju verziju izmjena, koja je kasnije pod njegovim vodstvom implementirana na IBM 360/50 računalu i koja je od 1966. postala poznata pod nazivom *Algol-W*, dok je *Algol Y* skupina nastavila u smjeru koji će kasnije završiti kao standard *Algol 68*, konačno implementiran 1972.

Medjutim, nezadovoljan praksom krpljenja postojećih jezika, kao i glomaznošću te nepotrebnim mogućnostima Algola, odlučio je "prekinuti kompatibilnost" i počeo od 1968. na bazi Algola raditi sasvim novi programski jezik, *Pascal*, koji je objavio 1970. godine.

Prvi Pascal prevodilac bio je napisan u Fortranu za CDC 6000 računalo. Druga verzija prevoditelja je napisana u samom programskom jeziku Pascal i objavljena 1971. godine (*The Programming Language Pascal*, Acta Informatica, 1, 35-63, 1971 i *The Design of a Pascal Compiler*, Software - Practice and Experience, 1, 309-333, 1971). Poboljšana verzija Pascala objavljena je 1973. u obliku *formalizirane sintakse* BNF (Hoare & Wirth: *An Axiomatic Definition of the Programming Language Pascal*, Acta Informatica, 2, 335-355, 1973). Godine 1974. objavljena je sredjena verzija (*Pascal User Manual and Report*) koja je uzeta kao osnova za standard jezika objavljen 1983. (ISO 7185:1983).

Pascal je brzo postao popularan i tražen zbog svoje jednostavnosti. Kao jezik koji je zadovoljavao najosnovnije zahtjeve strukturiranoga programiranja, bio je idealan izbor za učenje ove discipline kodiranja, ali i programiranja generalno. Napori mnogih univerziteta u svijetu da se prenese Pascal s IBM-a na druge računarske platforme doprinijeli su rapidnoj popularizaciji novoga programskoga jezika. Da bi se olakšao prijenos Pascala na različite platforme, smišljen je koncept *hipotetičkoga računala* (danas to zovemo virtualni stroj); Pascal kompilator, odnosno njegov *kôd-generator* je emitirao *p-kod* (skr. od *pseudo-code*, sad se to zove *[[bytecode]]*); *p-kod* se izvršavao na emulatoru koji je bilo relativno lako napisati u asembleru za bilo koju arhitekturu računala, tako da nije trebalo iznova programirati kompilator (*parser*, *generator kôda* itd), nego samo *interpreter* p-kôda ("emulator"), na kojem se onda mogao pokretati i originalni Pascal kompilator (u p-kodu). Ovakva metoda je mnogo doprinijela brzom širenju Pascala.

Pascal prevodilac bio je poslan, izmedju ostalih, i na University of California u San Diegu, gdje je nastala varijanta UCSD Pascal i u njemu kodirani p-System virtualni stroj. *p-System* se moglo prenijeti na veliki broj tadašnjih računala zahvaljujući činjenici da je trebalo programirati samo dijelove specifične za hardver. Program preveden *UCSD-Pascalom* u vidu *p-koda* mogao se izvršavati na svakom računalu koje ima *p-System*.

U isto vrijeme (1972) Dennis Ritchie napravio je programski jezik C za prvu verziju UNIX operacijskoga sistema na DEC PDP-7 računalu, po uzoru na nešto stariji B jezik Kena Thompsona, njegova radnoga kolege na AT&T Bell Labs. C je bio zasnovan na istoj proceduralnoj filozofiji kao i Pascal; za razliku od prvobitnoga Pascala, C je podržavao i osnovne tipove podataka kao što su realni brojevi dvostruke preciznosti (`double`). Medjutim, Wirth se kritički odnosi prema ovom suvremeniku Pascala, poredeći ga s asemblerom *više razine*, jer, iako *C* deklarativno podržava *tipove podataka*, tipovi prema njegovu mišljenju nemaju nikakva smisla ako programski jezik ne potencira *strogu tipiziranost*, odnosno kompajler ne provjerava *konzistentnost tipova*. Sličan kritički stav Wirth ima i u odnosu na C++, koji je svojevremeno bio *unazad-kompatibilna*, *objektno-orijentirana* nadogradnja na *C*; *C++* je, prema Wirthu, ogromni monstrum koji vremenom raste i sa svakom novom verzijom dobiva nove suvišne mogućnosti, postajući sve veći, sve teži za implementiranje i održavanje. Uz to je C++ kao *objektno-orijentirani jezik* i *jezik visoke razine* baziran na pogrešnoj osnovi, "C-assembleru".

Prvi masovno dostupni komercijalni Pascal kompajler bio je Turbo Pascal kompanije Borland, za operacijske sisteme CP/M i DOS. *Turbo Pascal* je kao prvo integrirano razvojno okruženje (IDE) omogućio lakši i brži razvoj softvera objedinjavanjem u jednu cjelinu editora, kompajlera i drugih pomoćnih programa (*Grep*, *Make*, *Touch* itd); masovnu popularnost dugovao je i svojoj relativno maloj cijeni od pedesetak dolara.

Operacijski sistemi za Apple računala Lisa i Macintosh s kraja sedamdesetih i početka osamdesetih bili su programirani u Pascalu, zbog čega pisanje programa u C-u za navedene sisteme nije imalo smisla, jer su programi morali raditi s tipovima podataka koje podržava standardni Pascal kao i API Apple OS-a. Prvobitni Object Pascal je najprije nastao u tvrtki Apple Computers, gdje je služio za sistemsko i aplikacijsko programiranje. Kasnije je *Object Pascal* implementiran u Borlandu, kroz komercijalne varijante Turbo Pascal i Delphi.

## Programska paradigma Pascala

Pascal svojom paradigmatskom filozofijom i dizajnom potencira strukturirano programiranje, pristup *kodiranju* gdje se *podatci* (i njihove *deklaracije*) strogo razdvajaju od *direktiva*, *procedura* i *funkcija* koji vrše obradu tih podataka.

*Strukturiran program* je program koji je temeljito razradjen kao *skup akcija* nad definiranim *skupom podataka*, a struktura podataka zapravo definira strukturu programa. Prije pojave Pascala dominirali su nestrukturirani, *sekvencijalni* programski jezici kao što su Fortran i Basic, u kojima je *kontrola toka* bila riješena upotrebom goto naredbe i označavanjem programskih linija rednim brojevima, u nedostatku proceduralnoga ili bilo kakva strukturalnoga rješenja u dizajnu jezika.

Proceduralni i funkcijski model u Pascalu znači da se *programski tok* može implementirati podjelom programa na *podprograme* (*procedure* i/ili *funkcije*), da bi se na taj način povećala *modularnost* i mogućnost recikliranja manjih abstrakcijskih cjelina programskoga kôda. Treba napomenuti da je *funkcijski* model u Pascalu podržan tek uvjetno rečeno, zato što *funkcije* u Pascalu, kao i u drugim proceduralnim jezicima, nisu *čiste funkcije* u smislu *funkcijske paradigme* programiranja, jer osim što evaluiraju izraze i vraćaju neku *vrijednost*, dopuštaju unutar sebe direktive i *promjene stanja* (*side-effects*); takve *funkcije* se suštinski ne razlikuju od imperativnih *procedura*, pa se mogu isto tako implementirati i kao *procedure s varijabilnim parametrima*.

Pascal je *strogo-tipizirani* jezik, što znači da ne dopušta upotrebu pojedinoga tipa podatka na mjestu gdje *operator* ili *funkcijski* odnosno *procedurni parametar* zahtijeva drugačiji tip. Izuzetak su *kompatibilni tipovi*, kao što su recimo `Integer` i `Byte`, ili `ShortInt`, `LongInt` i slični tipovi koji se ne razlikuju medjusobno po *vrsti*, nego samo po *maksimalnoj veličini* ili *hardverskoj implementaciji*, pod uvjetom da se mogu promovirati manji tipovi na mjesto većih, ali ne i obrnuto, jer bi došlo do gubitka preciznosti podatka.

## Sintaksa Pascala

Pascal spada u programske jezike kod kojih je *kapitalizacija* nebitna, što znači da se bilo koji *identifikator* ili *rezervirana*, *ključna riječ* (*keyword*) može napisati na različitim mjestima naizmjenično malim ili velikim slovima, ili kombinirano, bez ikakve razlike; prevodilac u svakom slučaju smatra da se radi o istom identifikatoru ili će prepoznati rezerviranu riječ bez obzira kako je kapitalizirana. Jezici kao što su C, C++, C# i Java razlikuju identifikatore i po kapitalizaciji naziva, pa je promjena samo jednoga slova iz maloga u veliko ili obrnuto, dovoljna da kompajler prijavi grešku, jer ne prepoznaje varijablu ili direktivu.

Osnovni elementi Pascal programa su *direktive* ili *naredbe* (engl. *statement*), koje se mogu sastojati od *izraza* (*ekspresija*) i drugih direktiva. Izrazi se sastoje od *operatora* i *operanada*. Operandi mogu biti *literalne* (*doslovne*) vrijednosti, ili reference *identifikatora*.

U *direktive* spadaju *deklaracije* (konstanti, varijabli, labela, procedura i funkcija), *definicije* (tipova podataka, procedura, funkcija), te tri osnovne vrste naredbi za *sekvenciju* (tok), *iteraciju* (ponavljanje) i *selekciju* (izbor).

### Deklaracije podataka

Pascal je programski jezik koji s obzirom na svoju strogo strukturiranu paradigmatsku opredijeljenost zahtijeva *deklariranje* svih podataka prije nego što se oni u programu *referenciraju*. Ovo je način da se postigne čitljivost i modularna upotrebljivost programskoga kôda, kao i odredjena vrsta programerske discipline. Ovakva filozofija programiranja je dosta različita od pristupa mnogih *interpretiranih* i *skriptnih* programskih jezika (od Basica do JavaScripta i drugih *dinamičkih* jezika), koji dopuštaju *implicitno referenciranje* varijabli bez deklaracija, ili čak implicitnu promjenu tipa (tzv. *loose-typing*). Osnovne vrste *direktiva* za opis podataka u Pascalu su deklaracije *konstanata*, *varijabli* i definicije *tipova*.

**Konstante** su identificirane doslovne (literalne) vrijednosti čijim se referenciranjem u programu ekspandira njihova (alfa)numerička vrijednost i na taj način se izbjegava višestruko uredjivanje na svim mjestima u programu gdje se ta vrijednost koristi. Deklariraju se direktivom `const`, nakon koje slijede identifikatori i vrijednosti, medjusobno razdvojene *znakom jednakosti*.

**Varijable** se deklariraju direktivom `var`, te navodjenjem imena identifikatora i naziva tipa podataka, izmedju kojih se stavlja *dvotočka*; može se deklarirati i više varijabli istoga tipa u jednoj direktivi, u kojem slučaju se izmedju imena varijabli stavlja *zarez*.

Izvedeni **tipovi** podataka definiraju se direktivom `type`, koja zahtijeva ime(na) identifikatora i definicije, izmedju kojih je *znak jednakosti*. Primjer deklaracija i definicija:


```pascal
const
  PROG_NAME = 'PhoneBook v1.0';
  PROG_FILE = 'pb.db';
  MAX_ITEMS = 1024;

type
  TShortString = array [1..64] of Char;
  TPhoneString = array [1..14] of '0'..'9';

  PPhoneBookPt = ^TPhoneBookEntry;

  TPhoneBookEntry = record
    Name: TShortString;
    Phone: TPhoneString;
    Email: string;
    Address: string;
    Link: PPhoneBookPt;
  end;

var
  PhoneBookEntry: TPhoneBookEntry;
  FPhoneBookData: file of TPhoneBookEntry;

procedure AddNewEntry; forward;
```


*Definicije tipova* (`type`) moraju u programu biti navedene prije *deklaracija varijabli* (`var`) koje su od toga tipa. Isto vrijedi i za definicije tipova podataka koje se pozivaju na neki drugi izvedeni tip. Jedini izuzetak je definicija tipa *pokazivača*, koja se može navesti prije ili poslije definicije *sloga* (`record`) ili *objekta* (`object` u *Object Pascalu*) na koji taj pokazivač ukazuje, kada taj objekt u sebi sadrži kao član isti takav tip pokazivača, jer u ovakom slučaju ne postoji način da se izbjegne *cirkularno referenciranje*; u tom slučaju, izmedju deklaracije pokazivača i definicije sloga (ili objekta) ne smije stojati nikakva druga definicija tipa ili direktiva, tj. ove dvije direktive moraju biti susjedne.

Generalno, u Pascalu svaka direktiva koja se poziva na neki *identifikator* zahtijeva da taj identifikator bude unaprijed deklariran ili definiran. Za potrebe referenciranja procedure ili funkcije prije njezine implementacije koristi se direktiva `forward` nakon deklaracije.

### Vrste podataka

Tipovi podataka u Pascalu dijele se na osnovne (skalarne) i strukturirane (izvedene), koji se uglavnom definiraju kao polja i slogovi sastavljeni od osnovnih ili drugih strukturiranih podataka.

#### Osnovni tipovi

Skalarne vrste podataka u Pascalu su:

* **[[cijeli broj]]evi** (`Integer`)
* **[[Realan broj|realni brojevi]]** (`Real`)
* **[[Alfanumerički znak|znakovi]]** (`Char`)
* **[[Booleova algebra|logičke vrijednosti]]** (`Boolean`)

Nadalje, pojedini tipovi podataka se klasificiraju kao **ordinarni**, što znači da se mogu sortirati prema veličini i manipulirati standardnim funkcijama `Pred()`, `Succ()`, `Ord()`. Od osnovnih tipova podataka, u ordinarne spadaju svi osim `Real`, jer decimalni broj ne može imati predhodnika ili sljedbenika po veličini.

#### Strukturirani tipovi

U strukturirane vrste podataka spadaju:

* **[[niz]]** ili polje (`array`)
* **[[niz znakova]]** (`string`)
* **[[slog]]** (`record`)
* **[[datoteka]]** (`file`)

#### Posebni tipovi

* **[[pokazivač]]** (`Pointer`)

**Pokazivač** je *metapodatak* koji ukazuje na *adresu* nekoga podatka u memoriji. Ovisno o tome pokazuju li na specifični *tip podatka* ili na *memorijsku lokaciju* s nedefiniranim tipom podataka, pokazivači se dijele na *tipizirane* i *generičke*. Generički pokazivači se deklariraju pomoću tipa podataka `Pointer`, za razliku od tipiziranih koji se deklariraju operatorom `^` prije naziva tipa (npr: `^Integer`).

Slično kao što se za tipizirane pokazivače *objekt u memoriji* stvara i briše procedurama `New()` i `Dispose()`, tako i za generičke pokazivače postoje procedure `GetMem()` i `FreeMem()` kojima se alocira i oslobadja *blok memorije* odredjene veličine:


```pascal
procedure GetMem(var P: Pointer; Size: Word);
procedure FreeMem(var P: Pointer; Size: Word);
```


Usmjeravanje pokazivača na *adresu* neke varijable, odnosno očitavanje te adrese i njezino zapisavanje u pokazivač vrši se operatorom `@` prije naziva varijable kojoj se želi pristupiti (npr: `PtrInt := @IntVar`).

Referenciranjem (pozivanjem) samoga imena pokazivača dobije se *adresa* varijable na koju on pokazuje, a stavi li se operator `^` iza imena, dobiva se *vrijednost* varijable na koju pokazivač pokazuje umjesto njezine adrese (npr: `IntVar^`); ovaj postupak se zove *dereferenciranje* pokazivača.

Dakle, ukratko:

* operator `^` prije *imena tipa* (`^Integer`) služi za *deklariranje* tipiziranoga pokazivača;
* operator `^` poslije *imena varijable* pokazivača (`IntVar^`) služi za *dereferenciranje* (pristup podatku);
* operator `@` služi za *adresiranje* (pridruživanje varijable pokazivaču);

Za informaciju o količini memorije koju zauzima neki tip varijable ili objekta postoji funkcija `SizeOf()`. Primjer upotrebe `SizeOf()` za prikaz veličine u bajtovima nekih tipova podataka:


```pascal
type
  Hobbit = Boolean;
  HoByte = array [1..8] of Hobbit;
           { 1 HoByte = 8 Hobbit }

begin
  WriteLn('    Byte = ', SizeOf(Byte));
  WriteLn('ShortInt = ', SizeOf(ShortInt));
  WriteLn('SmallInt = ', SizeOf(SmallInt));
  WriteLn(' LongInt = ', SizeOf(LongInt));
  WriteLn('   Int64 = ', SizeOf(Int64));
  WriteLn;
  WriteLn('  HoByte = ', SizeOf(HoByte), ' Hobbit');
end.
```


Navedeni program, ovisno o prevoditelju, operacijskom sistemu i arhitekturi računala može prikazivati različite rezultate (s tim da će `HoByte` svugdje biti `8 Hobbit`, bez obzira na hardver ili softver, zato što smo taj tip definirali unutar programa).

#### Enumeracije

**Enumeracije** ili **pobrojani tip** su izvedeni ordinarni tip podataka. Npr:


```pascal
type
  TMonth = (Jan, Feb, Mar, Apr, May, Jun,
            Jul, Aug, Sep, Oct, Nov, Dec);
```


#### Tipovi dosega

Pascal podržava varijable u odredjenom *dosegu* (području, podobsegu) nekoga drugoga ordinarnoga tipa podataka:


```pascal
var
  SmallNum: 1..128;
  SmallLtr: 'a'..'z';
```


Moguće je takodjer deklarirati varijablu u dosegu enumeriranoga tipa kojega smo predhodno definirali, pa s obzirom na gornji primjer definicije tipa možemo imati:


```pascal
var
  Summer: Jun..Aug;
```


Ista se sintaksa za dosege, naravno, može upotrijebiti i za definiranje tipova:


```pascal
type
  TDay = 1..31;
```


#### Setovi

Jedna od distinktivnih karakteristika Pascala u odnosu na druge programske jezike jest podržka za operacije sa skupovima, odnosno tip podataka `set`.


```pascal
var
  SmallNum: set of 1..128;
  SmallLtr: set of 'a'..'z';
```


Ova vrsta *sintaksnoga sladora* (engl. *sytactic sugar*) omogućuje pisanje elegantnijega i konciznijega kôda. Provjera pripadnosti elementa (vrijednosti varijable) nekom skupu vrši se pomoću operatora `in`. Dakle, možemo napisati ovo:


```pascal
if Number in [1..128] then
  { ... }
```


... ili još bolje ovo, s obzirom da smo deklarirali `SmallNum`:


```pascal
if Number in SmallNum then
  { ... }
```


... umjesto ovoga:


```pascal
if (Number > 0) and (Number < 129) then
  { ... }
```


Ovo je naročito zgodno kad treba izvršiti provjeru pripadnosti u većem broju ne-susjednih područja vrijednosti:


```pascal
if Number in [1..5, 17, 23, 25..32] then
  { ... }
```


### Kontrola toka

Konstukcije izbora (grananja), odnosno *kontrole toka* su If-Then, If-Then-Else i Case.

#### If-Then

**If-Then** se upotrebljava za kontrolu toka na osnovi uslova navedena u *izrazu* iza ključne riječi `if`. Ako je uslov izpunjen, izvršava se slijedeća naredba ili blok nakon ključne riječi `then`, a ako nije, programski tok preskače naredbu ili blok iza `then`, to jest nastavlja s izvršavanjem naredne direktive koja nije u sklopu *If-Then* konstrukcije, ukoliko postoji.


```pascal
if Izraz then
  Naredba;
```


Za izvršenje višestrukih naredbi koristi se `begin { ... } end` blok:


```pascal
if Izraz then
begin
  Naredba1;
  Naredba2;
  Naredba3;
  { ... }
end;
```


#### If-Then-Else

Za izbor izmedju dvaju mogućih tokova upotrebljava se **If-Then-Else** konstrukcija; prvi tok izvršava se u slučaju da je izpunjen uslov napisan izmedju `if` (*ako*) i `then` (*onda*), drugi u slučaju da nije, a stoji nakon rezervirane riječi `else` (*inače*):


```pascal
if Izraz then
  Naredba1
else
  Naredba2;
```


Ovdje vrijedi isto pravilo o zatvaranju blokova višestrukih direktiva izmedju `begin { ... } end;` direktiva:


```pascal
if Izraz then
begin
  Naredba1;
  Naredba2;
  Naredba3;
  { ... }
end { ovdje ne ide ";" }
else
begin
  Naredba4;
  Naredba5;
  Naredba6;
  { ... }
end;
```


#### Case

**Case** konstrukcija se upotrebljava kao preglednija alternativa za višestruko grananje toka, umjesto višestukih *if-then* direktiva ili *if-then-else* blokova u koncentričnom, kaskadnom i lančanom stilu.


```pascal
case Varijabla of
  1: Naredba1;
  2: Naredba2;
  3: Naredba3;
  4: Naredba4;
     { ... }
else { / otherwise }
  Naredba5; { default }
end; { case }
```


Navedeni `case` blok ekvivalentan je lančanom *else-if* u primjeru koji slijedi:


```pascal
if Varijabla = 1 then
  Naredba1
else if Varijabla = 2 then
  Naredba2
else if Varijabla = 3 then
  Naredba3
else if Varijabla = 4 then
  Naredba4
else
  Naredba5; { default }
```


### Sekvencija toka

U Pascalu svaka direktiva mora završavati znakom `;` (*točka-zarez*), osim ako je zadnja u *dosegu* (bloku, proceduri, funkciji ili programu), u kojem slučaju se može izostaviti, ali je dobra praksa ipak staviti `;` iza svake naredbe, zbog eventualnih kasnijih dodavanja novih.

Izuzetak je i zadnja direktiva prije ključne riječi `else` u If-Then-Else konstrukciji, ali u ovom slučaju se može smatrati da je *If-Then-Else* jedna naredba, posebna vrsta i drugačija od *If-Then*. Ovo je jedna od karakteristika Pascala koje ga razlikuju od jezika kao što su *C* i *C++*, koji zahtijevaju točka-zarez iza svakoga *if-then*, što praktično znači da se `else` u C/C++ prevoditeljima smatra posebnom naredbom, umjesto dijelom jedne *If-Then-Else* konstrukcije, a točka-zarez služi u tim jezicima kao *terminator* naredbi, umjesto kao samo *separator*; terminator naredbi se u C/C++ jezicima čak računa i kao poseban *statement*, jer se može staviti u *izvorni kôd* samostalno jedan ili više uzastopnih točka-zareza, a da kompajler to uredno prevede i ne prijavi sintaksnu grešku. Ovo, naravno, nije moguće u Pascalu.

Za rezerviranu riječ `else`, ako je dio `case` konstrukcije, takodjer ne vrijedi navedeni "izuzetak", pa se i krajnji slučaj `case` bloka prije `else` direktive mora terminirati točka-zarezom; za *case-else* konstrukciju postoji i rezervirana riječ `otherwise`, koja se može upotrijebiti umjesto `else`.

Blokovi direktiva u Pascalu se zatvaraju izmedju ključnih riječi `begin` i `end`, što je još jedna od njegovih karakterističnih razlika u odnosu na jezike C, C++, C#, Java itd, koji koriste vitičaste zagrade `{ }`. U programerskom žargonu ovi jezici se nazivaju *jezici vitičastih zagrada* (engl. *curly-brace languages*). Medju poznatije jezike koji imaju `begin` i `end` spada programski jezik Ada.

Zadnja `end` direktiva u programu završava *točkom* (`.`) umjesto *točka-zarezom*, i to je ujedno naredba zatvaranja bloka glavne procedure programa.

### Petlje

Direktive ponavljanja ili *petlje* su `for`, `while` i `repeat`, a njihova upotreba izgleda ovako:


```pascal
for Brojac := X to Y do
  Naredba;

for Brojac := X to Y do
begin
  { blok };
end;

while Izraz do
  Naredba;

while Izraz do
begin
  { blok };
end;

repeat
  { naredba / blok }
until Izraz;
```


Petlja `for` se ponavlja točno odredjen broj puta, a varijabla brojača se navodi kao područje izmedju dviju cjelobrojnih vrijednosti, oddvojenih rezerviranom riječju `to`. Petlja `while` provjerava neki uvjet naveden u *izrazu* prije ponavljanja *naredbe* ili bloka naredbi, za razliku od `repeat`, koja se najprije izvršava jedanput, a zatim provjerava uvjet u izrazu.

### Operatori

Operatori se dijele, s obzirom na to koliko operanda obradjuju, na *unarne* (jedan operand) i *binarne* (dva operanda).

Pascal koristi operator `:=` za pridruživanje vrijednosti, nasuprot jezicima kao što su *C* ili *C++*, gdje za to služi obični znak jednakosti (`=`). U Pascalu je znak `=` relacijski operator za logičke izraze - *ekspresije* (*C/C++* za to upotrebljava *dvostruki znak jednakosti*, `==`). Ova razlika može dovesti do konfuzije i grešaka u programiranju, naročito kod programera s izkustvom u Pascalu koji tek počinju programirati u jezicima C/C++, jer se izraz `if (i = 0)` (umjesto `if (i == 0)`) prevodi u C/C++ kompilatorima kao valjan *statement*.

Slijedi popis operatora u Pascalu.

#### Aritmetički operatori

 +    : sabiranje;
 -    : oduzimanje;
 *    : množenje;
 /    : dijeljenje;
 div  : cjelobrojno dijeljenje;
 mod  : ostatak cjelobrojnoga dijeljenja (modulus);

#### Relacijski operatori

 =    : jednako;
    : nejednako;
     : veće;
 >=   : veće ili jednako;

#### Logički operatori

 not  : logička negacija;
 and  : logičko *i*;
 or   : logičko uključivo *ili*;
 xor  : logičko izključivo *ili* (*or* s negacijom);

#### Operatori bitova

 shl  : lijevo pomjeranje;
 shr  : desno pomjeranje;

#### Ostali operatori

 with : selekcija sloga (record);
 in   : pripadnost skupu (set);
 to   : područje vrijednosti (for petlja);
 ..   : područje vrijednosti (array, set);
 ^    : deklariranje i dereferenciranje pokazivača;
 @    : adresiranje pokazivača;
 :=   : pridruživanje vrijednosti;

### Procedure i funkcije

Pascal razlikuje dvije vrste podprograma, **procedure** i **funkcije**. Funkcije za razliku od procedura vraćaju neku vrijednost, pa se prema tipu podataka koji vraćaju razlikuju i tipovi funkcija, što se navodi u deklaraciji. Drugi programski jezici uglavnom sve podprograme nazivaju isto, *funkcije* (C/C++), *subrutine* (Basic) itd. Naprimjer, u programskom jeziku *C*, procedura je obična funkcija koja vraća vrijednost `void` (ništa). Primjeri deklaracija procedure i funkcije, bez *implementacija*:


```pascal
function FileExists(Name: string): Boolean;
procedure PrintFile(Name: string);
```


#### Parametri

Parametri neke funkcije ili procedure su deklarirane unosne vrijednosti, a deklariraju se u u malim zagradama iza imena funkcije ili procedure, na isti način kao i varijable u `var` sekcijama.

Parametri mogu biti **vrijednostni** ili **varijabilni**. Varijabilni parametri mijenjaju vrijednost varijable pristupajući joj direktno (poziv po **referenci**) umjesto da rade s njezinom kopijom (poziv po **vrijednosti**), što se specificira direktivom `var` prije deklaracije parametra.


```pascal
procedure CheckIfFileExists(Name: string; var Exists: Boolean);
procedure MergeFiles(File1, File2: string; var NewFile: file);
```


Za razliku od vrijednostnih parametara, varijabilni parametri ne mogu prihvatiti konstantne vrijednosti (recimo neki broj ili string), nego samo *identifikatore* varijabli koje mijenjaju. Vrijednostni parametri mogu primati obje vrste *argumenata*, i doslovne vrijednosti, i imena varijabli.

#### Grupiranje

Nasuprot većini programskih jezika, Pascal podržava implementiranje *podprograma* (*procedure* i/ili *funkcije*) jedan unutar drugoga. Ova mogućnost se, medjutim, nerado upotrebljava u programerskom svijetu, jer ne doprinosi nimalo čitljivosti i upotrebljivosti izvornoga kôda, čak naprotiv. Preporuke "dobroga stila" programiranja u Pascalu obezhrabruju upotrebu unutarnjega grupiranja procedura za više od jedne razine. Neke implementacije Pascala, kao *Delphi*, ovu mogućnost ne podržavaju. Postoje, ipak, situacije kad je zgodno implementirati jednu proceduru unutar druge, kao što je slučaj s *quick-sort* algoritmom u slijedećem primjeru:


```pascal
procedure quicksort(var a: list; Lo,Hi: integer);
  procedure sort(l,r: integer);
  var
    i,j,x,y: integer;
  begin
    i:=l; j:=r; x:=a[(l+r) DIV 2];
    repeat
      while a[i]<x do i:=i+1;
      while x<a[j] do j:=j-1;
      if i<=j then
      begin
        y:=a[i]; a[i]:=a[j]; a[j]:=y;
        i:=i+1; j:=j-1;
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;
begin {quicksort};
  sort(Lo,Hi);
end;
```


### Standardne procedure i funkcije

#### I/O

Standardne procedure za unos su `Read` i `ReadLn`; `Read` zahtijeva najmanje jedan parametar, naziv varijable čija se vrijednost učitava, dok `ReadLn` pravi novi redak za svaku učitanu varijablu. Primjer:


```pascal
var
  Number: LongInt;

begin
  Write('Number? ');
  ReadLn(Number);
  WriteLn('Number: ', Number);
  ReadLn;
end.
```


Za izpis postoje procedure `Write` i `WriteLn`. Razlika izmedju njih je u tome što ova druga izpisuje tekst skupa sa prijelomom reda (linije), odnosno znakom za novi red (`CR/LF`).

#### Aritmetičke operacije

Neke od standardno ugradjenih aritmetičkih funkcija u Pascalu su:

 abs  : absolutna vrijednost broja (broj bez predznaka);
 exp  : potenciranje;
 sqr  : kvadrat;
 sqrt : kvadratni korijen;
 ln   : prirodni logaritam;
 sin  : sinus;
 cos  : kosinus;
 tan  : tangens;
 pred : predhodnik cijeloga broja;
 succ : sljedbenik cijeloga broja;
 round: zaokruživanje (vraća Integer);
 trunc: odbacivanje decimala (vraća Integer);
 int  : cijeli dio razlomka (vraća Real);
 frac : decimalni dio razlomka (vraća Real);

#### Operacije sa stringovima

Neke od standardnih funkcija za rad s nizovima znakova (stringovima):

 length : duljina stringa;
 copy   : kopiranje stringa;
 pos    : pozicija pojavljivanja podniza u nizu;
 delete : brisanje znakova;
 insert : umetanje znakova;
 str    : pretvara broj u string;
 val    : pretvara string u broj ili vraća grešku;

## Programski primjeri

### Faktorijel

Naredni program računa Faktorijel zadanih brojeva.


```pascal
program factorial;

function fact(n: integer): real;
begin
  if (n = 0) then
    fact := 1
  else
    fact := n * fact(n - 1);
end;

var
  n: integer;

begin
  for n := 0 to 16 do
    writeln(n, '! = ', fact(n):-1:0);
end.
```


### Fibonaccijevi brojevi

Slijedi program koji izpisuje Fibonaccijev niz.


```pascal
program fibonacci;

function fib(n: integer): integer;
begin
  if (n <= 2) then
    fib := 1
  else
    fib := fib(n - 1) + fib(n - 2);
end;

var
  i: integer;

begin
  for i := 1 to 16 do
    write(fib(i), ', ');

  writeln('...');
end.
```


## Varijante i dijalekti Pascala

* **UCSD Pascal** - Implementacija Pascala za virtuani stroj p-Machine na p-System OS-u.
* **ISO Pascal** - Standardni Pascal, prema specifikacijama *ISO/IEC 7185:1990 Pascal*  i *ISO/IEC 10206:1990 Extended Pascal* 
* **Turbo Pascal** - Uvodi mogućnosti kojih nema u ISO varijanti: programske *module* (od verzije 4.0), podržku za OOP (s verzijom 5.5).
* **Object Pascal** - Objektno orijentirani Pascal, danas zastupljen u dvama dijalektima: *Delphi* i *Free Pascal*. Object Pascal prvi put je implementiran na Apple računalima 1985.

## Razvojna okruženja

### Freeware

* **Free Pascal** - Multiplatformski Pascal i Object Pascal kompilator, u podpunosti kompatibilan s *Turbo Pascal* dijalektom i s djelomičnom podržkom za *Delphi*. Programski paket sadrži *Free Pascal Compiler (FPC)* i *FP IDE*, editor koji izgledom i funkcionalnošću imitira *Turbo Pascal IDE*. Postoje verzije FP paketa za slijedeće PC OS-ove: DOS, OS/2, Windows, Linux, BSD, MacOS, Netware i MorphOS, te druge platforme: Windows CE, Game Boy Advance, Nintendo DS, zatim za različite procesorske arhitekture: x86 (i386), x86-64 (amd64), PPC, PPC64, SPARC i arm. Link: *freepascal.org*
* **Lazarus** IDE - Grafičko sučelje za *Free Pascal Compiler (FPC)* i vizualno Pascal/Delphi programiranje. Podržava *Windows*, *Linux* i *MacOS*. Lazarus je skoro u podpunosti o API-ju neovisna platforma, tako da se isti izvorni kôd može prevoditi na svim sistemima s FPC-om. (*"Napiši jedanput, kompiliraj svugdje."*) Link: *lazarus.freepascal.org*
* **MSEide** - još jedan *Free Pascal* IDE, za *Linux* i *Windows*, no puno jednostavniji i manji od *Lazarusa*. Link: *homepage.bluewin.ch/msegui* | Arhivirano: *https://web.archive.org/web/20080624105137/http://homepage.bluewin.ch/msegui/* | *SourceForge.net* projekt: *https://sf.net/projects/mseide-msegui/*
* *Borland* **[[Turbo Pascal]]** - Linkovi za preuzimanje dviju najznačajnijih verzija:
** TP 5.5 | 
** TP 7.0 | 
* **Virtual Pascal** - Samostalan projekt autora *Allana Mertnera* i *Vitalyja Miryanova* od 1995 do 2005. Virtual Pascal je razvojno okruženje za *Windows* i *OS/2* s eksperimentalnom podržkom za *Linux*. *Virtual Pascal Compiler (VPC)* može linkovati 32-bitne egzekutivne datoteke za *Windows* (PE) i *OS/2*; u podpunosti je kompatibilan s *Turbo Pascalom*, dok *VP IDE* editor izgledom imitira *Turbo Pascal IDE*, pa je stoga VP svojevrstna prilagodba TP-a s 16-bitnoga DOS-a na 32-bitni Windows. Link: *vpascal.com* | Arhivirano: *https://web.archive.org/web/20051229123611/http://www.vpascal.com/news.php* | Softpedia link za preuzimanje zadnje verzije 2.1.279 iz 2004: *http://www.softpedia.com/get/Programming/Coding-languages-Compilers/Virtual-Pascal.shtml*
* **PascalABC.NET** - Razvojno okruženje za .NET Framework. Link: *pascalabc.net*
* **Inno Pascal** - Minimalistički Pascal IDE za *Win32* platformu, napisan u *Delphiju* (izvorni kôd je dostupan). S verzijom 0.1.5 (iz 2000. godine), *Inno Pascal* je napušteni projekt *Jordana Russella*, ujedno i autora popularnoga instalacijskoga sistema Inno Setup (koji, uzgred rečeno, ima ugradjen Pascal Script dijalekt Pascala kao skriptni jezik). Link: *jrsoftware.org* | Arhivirano: https://web.archive.org/web/20190901111031/http://other.jrsoftware.org/ip/
* **MiniPascal IDE** - Još jedan editor za *FPC*. Link: *minipascal.clan.st*

### Komercijalna

* *Borland* / *CodeGear* **Delphi**

## Bibliografija

### Literatura

* A. Lovrić: *Pascal. Osnove programiranja* | Tehnička knjiga, Zagreb, 1983.
* Z. Vlašić: *Pascal. Priručnik s riješenim primjerima (6. dopunjeno izdanje)* | Tehnička knjiga, Zagreb, 1991.
* I. Bratko, V. Rajkovič: *Računarstvo s programskim jezikom Paskal* | Nolit, Beograd, 1986.
* I. Hladni: *Pascal & Delphi programiranje* | Školska knjiga, Zagreb, 2004.

### Digitalni dokumenti

* *Computers and Computing: A Personal Perspective*, by Niklaus Wirth | ComputersAndComputing.pdf
* *Pascal: Skripta sa zadacima i rješenjima* | pascal1.pdf
* *Sa bejzika na pascal* - Novinski prilog časopisa *Računari* iz 1987 | bas2pas.zip
* *Roby's Pascal Tutorial*. Link: *http://www.geocities.ws/server2/homestead/codeteacher/pas/pasles00.html*

## Navodi