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

Povijest
--------

*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, kao i programiranja općenito. 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 tzv. *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*, *objekto-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
----------------

Ilustracija izvornoga kôda u Pascalu, kreirana pomoću LaTeXa
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 tzv. *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:

```
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 brojevi** (`Integer`)
* **realni brojevi** (`Real`)
* **znakovi** (`Char`)
* **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:

```
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:

```
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:

```
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:

```
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:

```
var
 Summer: Jun..Aug;

```

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

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

```
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:

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

```

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

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

```

... umjesto ovoga:

```
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:

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

```
if Izraz then
 Naredba;

```

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

```
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*):

```
if Izraz then
 Naredba1
else
 Naredba2;

```

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

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

```
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:

```
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:

```
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;
<    : manje;
<=   : manje ili jednako;
>    : 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*:

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

```
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:

```
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:

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

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

```
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:  | *SourceForge.net* projekt:

* *Borland* **Turbo Pascal** - Linkovi za preuzimanje dviju najznačajnijih verzija:
	+ TP 5.5 | Arhivirano 2007-10-27 na Wayback Machine-u
	+ TP 7.0 | Arhivirano 2011-11-07 na Wayback Machine-u

* **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:  | Softpedia link za preuzimanje zadnje verzije 2.1.279 iz 2004:

* **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:

* **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:

Navodi
------

1. ↑  Wirth: *Computers & Computing*, str. 14-15
2. ↑  Wirth, str. 16
3. ↑  Vlašić, str. 9
4. ↑  Vlašić, str. 9
5. ↑  Wirth, str. 16
6. ↑  Wirth, str. 16
7. ↑  Dennis M. Ritchie: *The Development of the C Language* | ACM, April 1993
8. ↑  Wirth, str. 17
9. ↑  Wirth, str. 24
10. ↑  Wirth, str. 17
11. ↑
12. ↑  Vlašić, str. 9
13. ↑
14. ↑  Hladni, str. 132
15. ↑  Hladni, str. 138
16. ↑  Hladni, str. 139
17. ↑
18. ↑
19. ↑  *How To Code: Pascal*, by Stan Sieler. Link:
20. ↑  *Turbo Pascal 5.5* Demos, *Turbo Sort* (`qsort.pas`)
21. ↑
22. ↑
23. ↑
24. ↑
25. ↑

***Pascal (programski jezik)*** na Wikimedijinoj ostavi