Այս հոդվածը Պասկալ ծրագրավորման լեզվի մասին է։  Այլ գործածությունների համար այցելեք Պասկալ(այլ կիրառումներ)։

**Պասկալը** (անգլ.՝ Pascal) հայտնի ծրագրավորման լեզուներից մեկն է, օգտագործվում է բարձր դասարաններին և համալսարանի առաջին տարում սովորողներին ծրագրավորում սովորեցնելու նպատակով, համարվում է մնացած լեզուների հիմնական բազան։

Պատմություն
-----------

Պասկալ լեզուն ստեղծվել է Նիկլաուս Վիրտի կողմից՝ 1968-1969 թվականներին Ալգոլ-68 լեզվի ստանդարտ զարգացման հանձնաժողովի աշխատանքում իր մասնակցությունից հետո։ Լեզուն անվանվել է ի պատիվ ֆրանսիացի մաթեմատիկոս, ֆիզիկոս, գրող և փիլիսոփա Բլեզ Պասկալի, ով ստեղծել է աշխարհում առաջին երկու նշանի թվերը գումարող մեխանիկական սարքը։ Լեզվի մասին Վիրտի առաջին տպագրությունը կատարվել է 1970 թվականին. ներկայացնելով լեզուն, հեղինակը որպես դրա ստեղծման նպատակը մատնանշեց փոքր և արդյունավետ լեզվի կառուցումը, նպաստումը լավ ծրագրավորման ոճին, օգտագործելով համակարգված ծրագրավորում և կառուցվածքային տվյալներ։

Վիրտի հետագա աշխատանքը ուղղված էր Պասկալի հիման վրա համակարգչային ծրագրավորման լեզու ստեղծելուն, պահպանելով բազայում համակարգված ինֆորմացիա ներմուծելու և պրոֆեսիոնալ ծրագրավորողներին սովորեցնելու հնարավորությունը ։ Այս աշխատանքի արդյունքը դարձավ Modula-2 լեզվի ստեղծումը։

Իրականացում և բարբառ
--------------------

**UCSD Pascal**
1978 թվականին Կալիֆոռնիայի Սան Դիեգո համալսարանում մշակվել էր UCSD p-System համակարգը, որը հանդիսանում է նախնական կոդերի խմբագիր, ֆայլային համակարգ և այլն, ինչպես նաև մեծ դեր ունեցավ Պասկալ լեզվի ընդլայնման գործում։ Հետագայում Պասկալի լեզվի հիմնական իրականացումները հիմնված էին այս բարբառի վրա։

**Object Pascal**
1986 թվականին Apple ընկերությունը մշակեց Պասկալ լեզվի օբյեկտի ընդլայնումը, ստանալով արդյունքում Object Pascal-ը։ Այն մշակվել էր Լարի Տեսլերի խմբի կողմից, որը խորհրդակցել էր Նիկլաուս Վիրտի հետ։

**Turbo Pascal և Object Pascal**
1989 թվականին լույս տեսավ Borland ընկերության Turbo Pascal-ի առաջին ինտեգրված միջավայրի տարբերակը։

1989 թվականին լեզվի առարկայական ընդլայնումը ավելացվել էր Turbo Pascal-ի 5.5 տարբերակին։

Վերջին տարբերակը (7.0) անվանափոխվել էր Borland Pascal:

Օբյեկտի ռեսուրսները օրինակվել էին Apple-ի Object Pascal-ից, լեզվային տարբերությունները Turbo Pascal 5.5-ի և Apple-ի Object Pascal-ի միջև չաձազանց աննշան էին։

Գրեթե նույն ժամանակահատվածում, Microsoft-ը արտադրեց Պասկալ լեզվի իր տարբերակը։ Պասկալի այդ տարբերակը լայն տարածում չգտավ։

Borland ընկերության Պասկալ լեզվի հետագա զարգացումից ծնվեց Object Pascal տարբերակը, որը ընկած է Delphi ծրագրավորման միջավայրի հիմքում։

Object Pascal-ի ժամանակակից տարբերակներ
---------------------------------------

Լեզվի զարգացման մեջ կարևոր քայլ է Պասկալ լեզվի ազատ իրականացման առաջացումը Free Pascal և GNU Pascal, որոնք կլանեցին լեզվի շատ այլ բարբառների առանձնահատկությունները, այլև ապահովեցին այնտեղ ստեղծված ծրագրերի ծայրահեղ լայն դյուրատարությունը (օրինակ, GNU Pascal-ն պահում է ավելի քան 20 տարբեր հարթակներ, ավելի քան 10 տարբեր օպերացիոն համակարգերի ներքո, Free Pascal-ն ապահովում է համատեղելիության հատուկ ռեժիմներ լեզվի տարբեր տարածված բարբառներով, ինչպիսիք են Turbo Pascal (լիարժեք համատեղելիություն), Delphi եւ այլն)։

Սկսած Delphi 2003-ից, ստեղծվել է լեզվի իրականացումը .Net պլատֆորմայում, չնայած մշակողները շարունակում են օգտագործել Delphi-ի նախկին տարբերակները։

Free Pascal, GNU Pascal և TMT Pascal-ի առևտրային զարգացումների մասին այս պահին քիչ բան է հայտնի։

Լեզվի առանձնահատկություններ
---------------------------

Լեզվի առանձնահատկությունները հանդիսանում են խիստ մուտքագրումով և կառուցվածքային (ընթացակարգային) ծրագրավորման միջոցների առկայությամբ։ Վիրտի կարծիքով, լեզուն պետք է աջակցի կարգապահական ծրագրավորմանը, հետևաբար խիստ տպագրման հետ մեկտեղ, Պասկալը հնարավորինս նվազեցնում է հնարավոր սինթետիկ անորոշությունները, և ինքը շարադրում է այն, ինչը հեղինակը փորձել է ինտուիտիվ հասկանալի դարձնել նույնիսկ լեզվի հետ ծանոթության ժամանակ։

Այնուամենայնիվ, նախնական լեզուն ուներ մի շարք սահմանափակումներ. դինամիկ հիշողության հետ աշխատելու բնականոն գործիքների բացակայություն, սահմանափակ ներմուծելու և արտածելու գրադարան, այլ լեզուներով գրված գործառույթների միացման հնարավորությունների բացակայություն, առանձին կազման միջոցների բացակայություն և այլն։ Պասկալի այդ ժամանակի թերությունների մանրամասն վերլուծությունը կատարեց Բրայան Քերնիագանը «Ինչու Պասկալը իմ սիրած ծրագրավորման լեզուն չէ» հոդվածում (այս հոդվածը գրվել է 1980-ական թվականների սկզբին, երբ արդեն գոյություն ուներ Modula-2-ը՝ Պասկալի հետնորդը)։ Պասկալի թերություններից մի քանիսը ուղղվել էին ISO-ի 1982 թվականի ստանդարտով, մասնավորապես, լեզվում առաջացել էին բաց զանգվածներ, որոնք հնարավորություն էին տվել օգտագործել նույն զանգվածները, տարբեր չափերի զանգվածները մշակելու համար։

Սակայն, որոշ լեզվի թերությունները չէին երևում, կամ նույնիսկ արժանի էին օգտագործվելու ծրագրավորում սովորեցնելու համար։ Բացի այդ, 1970-ական թվականների ակադեմիական հիմնական ծրագրավորման լեզվի հետ համեմատած(որը Ֆորտրանն էր, ուներ ավելի շատ թերություններ), Պասկալը նշանակալի առաջընթաց էր։ 1980-ական թվականներին Պասկալը դարձավ որոշ ուսուցողական ծրագրերի հիմքը, որոշ դեպքերում նրա հիման վրա ստեղծվել էին ծրագրավորման ուսուցողական լեզուներ, այսպիսով, 1980-ական թվականների սկզբին Անդրեյ Էրշովը ստեղծեց ալգոլա-պասկալային «կրթական ալգորիթմային լեզու»-ն, դպրոցականներին դասավանդելու համակարգչային գիտության և համակարգչային գիտության հիմունքները։

Պասկալի հայտնի իրականացումը, որն ապահովում է լեզուների լայն տարածումն ու զարգացումը, հանդիսանում է Borland ընկերության Turbo Pascal-ը։

Ստանդարտներ
-----------

1970 թվականին՝ Պասկալի օգտագործման սկիզբը և իրականացման առաջացումը՝ որոնք տարբերվում էին ոչ միայն լրացումներով, այլև շարահյուսությամբ, հարց բարձրացվեց լեզվի ստանդարտացման վերաբերյալ։ Ստանդարտ լեզուն մշակել է Նիկլաուս Վիրտը, Կետլին Ջենսենի հետ 1974 թվականին։ Հետագայում ANSI-ից ստացվեց ISO ստանդարտ և ամերիկյան ստանդարտ։ Unextended Pascal (նախնական), Extended Pascal (ընդլայնված), Object-Oriented Extensions to Pascal (Պասկալի վրա հիմնված օբյեկտիվ ընդլայնումը)

Պասկալ լեզվի ստանդարտները. նախնական, միջազգային ISO և Ամերիկյան ANSI| Անվանում | Տարբերակ | Ում կողմից/որտեղ է մշակված | Ստեղծման թիվը |
| --- | --- | --- | --- |
| Pascal Standard | նախնական | Ն. Վիրտ, Քեթլին Ջենսեն | 1974 |
| Pascal Standard | նախնական | ISO 7185:1983ANSI/IEEE 770X3.97:1983 | 1982 |
| Unextended Pascal | նախնական | ISO 7185:1990 | 1989 |
| Extended Pascal | ընդլայնված | ANSI/IEEE 770X3.160:1989 | 1989 |
| ISO/IEC 10206 | 1991 |
| Object-OrientedExtensions to Pascal | օբյեկտիվ ընդլայնում | ANSI/X3-TR-13:1994 | 1993 |

Extended Pascal օբյեկտիվ ընդլայման հիմնական լրացուցիչ առանձնահատկություններից մեկը մոդուլյարությունը և միջոցներն էին հեշտացնելով առանձին կոմպիլյացիան։

Սինտացիա և լեզվային կառուցվածքներ
---------------------------------

Պասկալը, իր նախնական ձևով, միանգամայն ընթացակարգային լեզու է և ներառում է բազմաթիվ ալգորիթմային կառուցվածքներ և կառույցներ, ինչպես օրինակ, if, then, else, while, for և այլն։ Այնուամենայնիվ, Պասկալը պարունակում է մեծ քանակությամբ հնարավորություններ աբստրակցիաների և ինֆորմացիաների կառուցվածքի վերաբերյալ, որոնք բացակայում են սկզբնական Ալգոլ-60-ում, ինչպիսին են տիպային սահմանումները, գրառումները, ցուցիչները, թվերը և սահմանումները։ Ժամանակակից բարբառներում (Free Pascal) գործում են համակարգեր, ինչպիսին է ֆունկցիաների և օպերատորների ծանրաբեռնվածությունը։

**Hello, world!**
Պասկալում ծրագրերը սկսում են **Program** բառով, որին հաջորդում է ծրագրի անունը՝ վերջում **կետ ստորակետով**(որոշ բարբառներում վերջինս պարտադիր չէ), անվանը կարող են հաջորդել պարամետրերի մեջ պարունակվող արտաքին ֆայլերի նկարագրիչների («միջավայր») ցուցումները, որին հաջորդում է ծրագրի մարմնը, որը բաղկացած է Const, Type, Var ընթացակարգային բաժիններից և գործառույթներից, որին էլ հաջորդում է ծրագրի օպերատորի բլոկը, որը ծրագրի մուտքի կետն է։ Պասկալում բլոկը սկսվում է **begin** բառով և վերջանում **end**-ով։ Օպերատորները միմյանցից բաժանվում են կետ ստորակետով(;), իսկ ծրագրի վերջում դրվում է կետ(.), որը ցույց է տալիս վերջինիս ավարտը։

Պասկալում սիմվորլների գրանցումը կարևոր չէ

Այսպիսով, Պասկալի «դատարկ» ծրագիրը կունենա հետևյալ տեսքը.

```
program p;
begin
end.

```

Վերևում ներկայացված ծրագիրը ոչ մի գործողություն չի կատարում և պարունակում է օպերատորների դատարկ բլոկ։

Ծրագրի օրինակ, որը տպում է «Hello, world!» արտահայտությունը.

```
begin
 writeln('Hello, World!'); { տողերի ելքի օպերատոր }
end.

```

### Տվյալների տիպեր

#### Պարզ տիպեր

Ստանդարտ և ընդլայնված Պասկալում կան հետևյալ **պարզ** տիպերը` սահող կետով (real), ամբողջ (integer), սիմվոլային (char), տրամաբանական (boolean) և թվարկող (Պասկալում ներկայացված նոր տեսակի կոնստրուկտոր)։

Turbo Pascal-ը ավելացրեց այս տիպերի վարիացիաները. օրինակ՝ shortint-ը integer-ից ավելի կարճ կլինի, իսկ longint-ը՝ երկար։

#### Թվային տիպեր

| Տիպ | Չափ | Ֆորմատ | Չափը բայթերով | Նշումներ |
| --- | --- | --- | --- | --- |
| Byte | 0..255 | Ոչ նշանային | 1 |  |
| ShortInt | −128..127 | Նշանային | 1 |  |
| SmallInt | −32768..32767 | Նշանային | 2 | Հնարավոր է գոյություն չունենալ. դրա փոխարեն դնում են Integer նույն տիրույթով |
| Word | 0..65535 | Ոչ նշանային | 2 |  |
| LongWord | 0..4294967295 | Ոչ նշանային | 4 |  |
| LongInt | −2147483648..2147483647 | Նշանային | 4 |  |
| Int64 | −9223372036854775808..9223372036854775807 | Նշանային | 8 |  |
| QWord | 0..18446744073709551615 | Ոչ նշանային | 8 |  |
| Integer | -32768..32767. | Նշանային | 2 | Ամենաարագը և ամբողջականը. SmallInt կամ LongInt |
| Cardinal |  ? | Ոչ նշանային |  ? | Ամենաարագը և ամբողջականը. հիմնականում LongWord |
| NativeInt |  ? | Նշանային |  ? |  |
| NativeUInt |  ? | Ոչ նշանային |  ? |  |

Սահող ստորակետովի թվերը

| Տիպ | Չափ | Թվերի տիրույթ | Չափը բայթերով | Աջակցություն |
| --- | --- | --- | --- | --- |
| Real | կախված է տիրույթից |  ??? |  ??? | Բոլոր կոմպիլյատորները. ժամանակակից է սովորաբար համարվում Double էկվիվալենտը |
| Real48 | −39..38 | 11−12 | 6 | Borland. Turbo Pascal-ում անվանվում է Real |
| Single | −45..38 | 7−8 | 4 | Տարբերակների մեծամասնությունը IEEE 754-ով |
| Double | −324..308 | 15−16 | 8 | Տարբերակների մեծամասնությունը IEEE 754-ով |
| Extended | −4951..4932 | 19−20 | 10 | Տարբերակների մեծամասնությունը x86-ով |
| Comp | −9223372036854775808..9223372036854775807 | 8 | Borland; |
| Currency | −922337203685477.5808..922337203685477.5807 | 8 | Borland |

```
var { փոփոխական հայտարարագրման բաժին }
 r: Real; { իրական տիպի փոփոխական }
 i: Integer; { integer տիպի փոփոխական }
 c: Char; { բնույթի փոփոխական }
 b: Boolean; { տրամաբանական փոփոխական }
 s: String; { տողային փոփոխական }
 t: Text; { տեքստային ֆայլը հայտարարելու համար փոփոխական }
 e: (apple, pear, banana, orange, lemon); { թվարկելու համար փոփոխական }

```

Պասկալում ամբողջ տիպերին (byte, shortint, word, integer, longint և դրանց միջակայքերը) թույլատրվում են բիթերով գործողությունները։

Երկու ամբողջ գործոնների բիթերի վրա կարելի է կատարել նախկինում դիտարկված տրամաբանական գործողություններ` not, and, or, xor:

Դիապազոնները պարունակում են այլ տիպերի ենթաբազմություններ.

```
var
 x: 1..10;
 y: 'a'..'z';
 z: pear..orange;

```

Հաջորդական տիպերի համար սահմանված են `inc`, `dec`, `succ`, `pred`, `ord` գործողությունները, համեմատական գործողություններ՝ (`=` `>` `<` `=>` `<=` `<>`), սրանք կարելի է օգտագործել `case`, `for` (որպես ցիկլի հաշվիչ) օպերատորներում, ինչպես զանգվածի սահման, տարրերի տեսակների և սահմանման համար։

Պասկալում, ի տարբերություն C-ի նման լեզուների, boolean և char տիպերով թվաբանական ամբողջական գործառույթներ չեն սահմանվում։

#### Բազմություններ

Ի տարբերություն շատ տարածված լեզուների, Պասկալը աջակցում է հատուկ տվյալների տիպերի բազմությանը.

```
var
 set1: set of 1..10;
 set2: set of 'a'..'z';
 set3: set of pear..orange;

```

Բազմությունը ժամանակակից մաթեմատիկայի հիմնավոր հասկացություն է, որը կարող է օգտագործվել բազմաթիվ ալգորիթմների մեջ։

Պասկալում բազմության տիպը կարող է պարունակել միայն հեթական տիպի միատիպ տարրեր։ Այս առանձնահատկությունը լայնորեն օգտագործվում է և սովորաբար ավելի արագ է, քան լեզուների էկվիվալենտության կառուցվածքը, որը չի աջակցում բազմությանը։ Օրինակ՝ Պասկալի շատ հեղինակների համար.

```
if i in [5..10] then { տարրերի բազմությանը պատկանելու ստուգում }
...

```

Ավելի արագ է մշակվում, քան.

```
if (i>=5) and (i<=10) then { տրամաբանական պայմանի ստուգում }
...

```

Բազմությունների արժեքները սահմանելու համար օգտագործվում է բազմության տարրերի ցուցակը, առանձնացված ստորակետերով և քառակուսի փակագծերով.

```
var { փոփոխական հայտարարագրման բաժին }
 d:set of char;
begin { բլոկի սկիզբ }
 d:=['a','b']; 
...

```

#### Բաղադրիչ տիպեր

Նոր տիպերը կարելի է սահմանել առկաներից.

```
type { տիպերի հրապարակման բաժին }
 x = Integer;
 y = x;
...

```

Ավելին, պարզ տիպերից կարելի է կառուցել բաղկացուցիչները.

```
type { տիպերի հրապարակման բաժին }
 a = Array [1..10] of Integer; { զանգվածի սահմանում }
 b = record { գրառման սահմանում }
 x: Integer;
 y: Char;
 end;
 c = File of a; { ֆայլի սահմանում }

```

Պասկալի ֆայլային տիպերը բաժանվում են տպագրված, տեքստային և առանց տիպերի ֆայլեր։

Ինչպես ցույց է տրվել վերը նշված օրինակում, Պասկալում տպագրված ֆայլերը նույն տիպի տարրերի հաջորդականությունն են։ Յուրաքանչյուր ֆայլի համար գոյություն ունի բուֆերային նշիչ, որը նշանակում է f^: Get (կարդալու համար) և put (գրառման համար) պրոցեդուրաները ցուցիչը տեղափոխում են հաջորդ տարրի վրա։ Տարրերի կարդալը իրականացվել է այնպես, որ read(f, x) նունն է, ինչպես get(f); x:=f^: Հետրաբար, գրառումը իրականացվում է այնպես, որ write(f, x) իրենից ներկայացնում է նույնը, ինչ-որ f^ := x; put(f)-ը։ Տեքստային ֆայլերը text սահմանվում են ինչպես file of char տիպի ընդլայնում, և բացի տպագրված ֆայլերի ստանդարտ գործառնություններից (կարդալ, սիմվոլի գրառումը), նրանք թույլ են տալիս իրականացնել մուտք-ելք բոլոր տիպի ֆայլերում։

Առանց տիպի ֆայլերը հայտարարվում են ինչպես file տիպի փոփոխականներ։ Նրանց հետ կարող ենք կատարել մուտք-ելք չտիպավորված գործողությունները, քանի որ բլոկների որոշակի երկարությունը սահմանված է բուֆերի միջոցով, այս ամենի համար օգտագործվում են հատուկ պրոցեդուրաներ՝ blockread և blockwrite (UCSD ընդլայնում)։

#### Տողեր

Ժամանակակից Պասկալում  տողերի աշխատելու համար օգտագործվում է string տիպը, որն աջակցում է կապակցման (+) և համեմատական գործողություններին (> < = <> >= <=): Տողերը համեմատվում եմ բառարանագրական հերթականությամբ։ Օրինակ՝ տողերը համարվում են հավասար, եթե դրանք ունեն նույն երկարությունը և բոլոր սիմվոլների կոդերը համընկնում նրանց ինդեքսներին։

String [n] կամ ուղղակի string տիպը 1970-1990-ի լեզվի բարբառներում սահմանվել է զանգվածի array [0..n] of char (n-ը UCSD Pascal-ում ընդունում է 80 արժեքը, իսկ Turbo/Borland Pascal-ում՝ 255) սիմվոլներով։ Զանգվածի զրոյական տարրը այս ներկայացմամբ, ծառայում է տողերի երկարությունը նշելու համար, համապատասխանաբար, տողը կարող է ունենալ առավելագույնը 255 նիշ։ Սկզբնական տեսքում Delphi-ում և FreePascal-ում String-ի փոխարեն օգտագործվում է AnsiString-ը, որի հիշողությունը առանձնանում և ազատվում է դինամիկորեն կոմպիլյատորի կողմից, իսկ տողի առավելագույն չափը կազմում է 2 գիգաբայթ։

Delphi 2009-ում համապատասխան կոդային էջը (վերևում նշված է AnsiString-ի կոնստրուկցիան).

```
type
 CyrillicString = AnsiString(1251);
 CP866String = AnsiString(20866);

```

#### Ցուցիչներ

Պասկալը խրախուսում է ցուցիչների օգտագործումը (տիպավորված ^tipe և չտիպավորված՝ pointer)

```
type
 a = ^b;
 b = record
 x: Integer;
 y: Char;
 z: a;
 end;
var
 pointer\_to\_b:a;

```

Այստեղ օգտագործված pointer\_to\_b փոփոխականը b-ի տվյալների տիպի ցուցիչն է։

Տպագրված ցուցիչի համար սահմանվում է վերադասավորման գործողություն (շարահյուսություն՝ ցուցիչ^):

Նոր գրառում ստեղծելու և 10-ի արժեքը նշանակելու, A սիմվոլի ու x և y դաշտերը բնութագրելու համար հարկավոր են հետևյալ օպերատորները.

```
new(pointer\_to\_b); { հիշողությունը ցուցիչին հատկացնելը }

pointer\_to\_b^.x := 10; { ցուցիչի արտաբերումը և գրառման դաշտ մուտք գործելը }
pointer\_to\_b^.y := 'A';
pointer\_to\_b^.z := nil;
...
dispose(pointer\_to\_b); { ցուցիչի տակ գտնվող հիշողությունից ազատվելը }

```

Գրառումների և օբյեկտների ոլորտներում մուտք գործելու համար կարող եք նաև օգտագործել `with` օպերատորիը, ինչպես ցույց է տրված օրինակում.

```
new(pointer\_to\_b);

with pointer\_to\_b^ do
begin
 x := 10;
 y := 'A';
 z := nil
end;
...
dispose(pointer\_to\_b);

```

#### Ընթացակարգային տիպ

Վիրտը և Ջենսենը ընթացակարգային տիպը օգտագործվել են միայն ֆորմալ պարամետր նկարագրելու համար։ Արդեն TP-ում գոյություն ուներ լիակատար ընթացակարգային տիպ։ Ընթացակարգային տիպում նշվում է ընթացակարգի կամ գործառույթի վերնագիրը (առանց անվան), որը ընդհանուր առմամբ նկարագրում է ենթածրագրերիի ինտերֆեյսը։ Այս տիպի իմաստը կայանում է նրանում, որ այն պարունակում է ենթածրագրով ցուցիչ, որը տիպային հռչակագրում նկարագրված է համապատասխան վերնագրով։

*Pascal-ի ենթածրագրի օրինակ՝*

```
type myfunc=function:string;

function func1:string;
begin
 func1:='func N 1'
end;

function func2:string;
begin
 func2:='func N 2'
end;

var fun:myfunc;
begin
 fun:=@func1;
 writeln(fun) {կատարվում է func1 ֆունկցիայի կանչը}
end.

```

### Կառավարման օպերատորներ

Պասկալը համակարգված ծրագրավորման լեզու է, ինչը նշանակում է, որ ծրագիրը բաղկացած է առանձին ստանդարտ օպերատորների հրամանների հերթական կատարումից, առանց goto հրամանի օգտագործմամբ։

Օրինակ՝ Պասկալի համար.

```
while a <> b do { նախապայմանով ցիկլ }
 writeln('Սպասում');

if a > b then { պայմանի օպերատոր }
 writeln('պայմանը կատարվել է')
else { else-բաժինը կարող է բացակայել }
 writeln('Պայմանը չի կատարվել');

for i := 1 to 10 do { Պարամետրով ցիկլ }
 writeln('Ինտերացիա №', i:1);

for i in [1..10] do { բազմության դեպքում պարամետրով ցիկլ }
 writeln('Ինտերացիա №', i:1);

with a do {With օպերատորը գրառման բաժինների մուտքի արագացման մեթոդն է}
 begin
 l:=1;
 k:=2;
 p:=-3;
 end;

repeat { հետպայմանով ցիկլ }
 a := a + 1
until a = 10;

case i of { բազմակի ընտրության պայմանական օպերատոր }
 0: write('զրո');
 1: write('մեկ');
 2: write('երկու')
 else write('անհայտ թիվ') { else-բաժինը կարող է բացակայել}
end;

```

While, for, if, case օպերատորներում իրականացնող օպերատորի դերում կարող է օգտագործվել *բլոկը*։ Այդպիսի կոնստրուկցիան, որը իրենից ներկայացնում է սովորական օպերատոր կամ բլոկ, կոչվում է *բարդ օպերատոր*։

Turbo Pascal-ում կոմպիլյացիաների գործընթացը ղեկավարելու համար գոյություն ունեն հրահանգներ, որոնք տեղադրվում են մեկնաբանություններում և հնարավորություն են տալիս կոմպիլյատորի աշխատանքի ռեժիմը փոփոխել։ Օրինակ՝ անջատել, կամ միացնել մուտք-ելքի օպերացիայի ստուգումը։

Օրինակ Պասկալի համար՝
|content=

```
 assign(inp,'text.txt');
 {$I-} { IO checking ռեժիմի անջատում }
 { (այն դեպքում, երբ ֆայլը գտնված չէ)} 
 reset(inp);
 {$I+} { IO checking ռեժիմի միացում }
 if IOresult=0 then begin 
 ...
 close(inp);
 end else writeln('file not found')

```

Կան կոմպիլյատորներ, որոնք նման են C/C++ (`$ifdef`, `$define`, `$include`) պրոցեսորային դիրեկտիվներին, դրանք կազմվում են կոմպիլյատորի կողմից կազմման գործընթացում

Պրոցեդուրաներ և ֆունկցիաներ
---------------------------

Պասկալում ենթածրագրերը բաժանվում են պրոցեդուրաների և ֆունկցիաների։ Այդուհանդերձ, ֆունկցիաները վերադարձնում են համապատասխան տիպի արդյունքը, իսկ պրոցեդուրաները՝ ոչ։

Գործառույթի շարահյուսորեն նկարագրությունը կամ ֆունկցիան բաղկացած է վերնագրից, որը պարունակում է procedure կամ function բանալի բառերը, որին կարող է հետեւել փակագծերի մեջ գրված փոխանցման (ֆորմալ) պարամետրերի նկարագրությունը։ Ֆունկցիայում վերջակետը `:` ցույց է տալիս վերադարձվող արժեքի տիպը։ Վերնագիրը ավարտվում է կետ-ստորակետով `;`: Վերնագրին հաջորդում է ծրագրի մարմինը, որը պարունակում է տիպերի, ֆունկցիաների, գործառույթների նկարագրությունը եւ (անպայման) օպերատորների բլոկը, որից հետո դրվում է կետ-ստորակետ `;`:

Ծրագրի օրինակ Պասկալի համար՝

program mine(output);

var i : integer;

procedure print(var j: integer);

```
 function next(k: integer): integer;
 begin
   next := k + 1
 end;
```

begin

```
 writeln('Всего: ', j);
 j := next(j)
```

end;

begin

```
 i := 1;
 while i <= 10 do
   print(i)
```

end.

Ծրագրի մարմինը, ինչպես ծրագիրը, իր հերթին կարող է պարունակել ընթացակարգերի եւ ֆունկցիաների նկարագրությունը։

#### Պասկալի ստանդարտ մաթեմատիկական ֆունկցիաներ եւ ընթացակարգեր

##### Մաթեմատիկական ֆունկցիաներ

|  |  |  |  |
| --- | --- | --- | --- |
| Ֆունկցիայի անունը | Արգումենտի տիպը | Արժեքի տեսակը | Հաշվարկի արդյունքը
  |
| Abs(x) | ամբողջ իրական | ամբողջ իրական | Абсолютное значение "х" 
  |
| Sin(x) | իրական | իրական | սինուս "х" 
  |
| Cos(x) | իրական | իրական | կոսինուս "х" 
  |
| Arctan(x) | իրական | իրական | արկտանգես "х" ( -Pi/2 <y< Pi/2 ) 
  |
| Sqrt(x) | իրական | իրական | "х"-ի քառակուսի արմատ 
  |
| Sqr(x) | ամբողջ իրական | ամբողջ իրական | "х"-ի քառակուսի ( *x*2 ) 
  |
| Power(a,x) | իրական | իրական | "a"-ի "x" աստիճան ( *a*x )
  |
| Exp(x) | իրական | իրական | "х"-ի "е" աստիճան ( *e*x, որտեղ e= 2.718282... ) 
  |
| Ln(x) | իրական | իրական | "х"-ի բնական լոգարիթմը ( х > 0 ) 
  |
| Frac(x) | իրական | իրական | "х"-ի մասնակի մասը
  |
| Int(x) | իրական | իրական | "х"-ի ամբողջ մասը
  |
| Random | - | իրական | պատահական թիվ ( 0 <=y< 1 ) 
  |
| Random(x) | Word | Word | պատահական թիվ ( 0 <=y< x ) 
  |
| Succ(c) | հաջորդական | հաջորդական | "с"-ին հաջորդող սիմվոլը 
  |
| Pred(c) | հաջորդական | հաջորդական | "с"-ին նախորդող սիմվոլը |

##### Մաթեմատիկական ընթացակարգեր

|  |  |  |  |
| --- | --- | --- | --- |
| Ֆունկցիայի անունը | Արգումենտի տիպը | Արժեքի տեսակը | Հաշվարկի արդյունքը
  |
| Inc(x) | ամբողջ | ամբողջ | 1-ով ավելացնում է "х"-ը ( x:=x+1; ) 
  |
| Dec(x) | ամբողջ | ամբողջ | 1-ով պակասացնում է "х"-ը ( x:=x-1; ) 
  |
| Inc(x , n) | ամբողջ | ամբողջ | n-ով ավելացնում է "х"-ը ( x:=x+n; )
  |
| Dec(x , n) | ամբողջ | ամբողջ | n-ով պակասացնում է "х"-ը ( x:=x-n; ) |

##### Փոփոխականի տիպերի փոխարկման ընթացակարգեր

|  |  |  |  |
| --- | --- | --- | --- |
| Ֆունկցիայի անունը | Արգումենտի տիպը | Արժեքի տեսակը | Հաշվարկի արդյունքը
  |
| Str(x , s) | x-ամբողջ կամ իրական | s-տողային | "x" թվի թվանշաններից "s" սիմվոլների հաջորդականություն 
  |
| Val(s , v, cod) | s-տողային | v-ամբողջ կամ իրական cod-ամբողջ | թվերի "s" հաջորդականության երկրորդ ձեւը cod=0 (սխալ կոդ) |

##### Փոփոխականի տիպերի փոխարկման ֆունկցիաներ

|  |  |  |  |
| --- | --- | --- | --- |
| Ֆունկցիայի անունը | Արգումենտի տիպը | Արժեքի տեսակը | Հաշվարկի արդյունքը
  |
| Trunc(x) | իրական | LongInt | "х"-ի ամբողջ մասը
  |
| Round(x) | իրական | LongInt | "х"-ի կլորացմամբ 
  |
| Odd(x) | ամբողջ | տրամաբանական | վերադարձնում է True եթե "х"-ը կենտ թիվ է 
  |
| Chr(x) | Byte | Char | "х"-ի ASCII սիմվոլը
  |
| Ord(x) | Char | Byte | "x" սիմվոլի ASCII կոդը |

#### Մոդուլներ

Մինչեւ մոդուլների կապի հայտնվելը ներկայիս տեսքով, Պասկալի որոշակի իրականացումները աջակցում էին մոդուլյարությունը վերնագրի ֆայլերի միացման մեխանիզմների միջոցով, ինչպես С լեզվում `#include` մեխանիզմը։ Այսպիսով, կարելի էր ծրագրային կոդը բաժանել մի քանի մասերի՝ խմբագրման հեշտության համար, բայց նախքան կոմպիլյացիան, դրանք ավտոմատ կերպով միանում էին մեկ ծրագրային ֆայլի մեջ, որը ի վերջո մշակվում էր կոմպիլյատորի կողմից։ Մոդուլյացիայի այս իրականացումը պարզունակ էր եւ շատ ակնհայտ թերություններ ուներ, ուստի այն արագ փոխարինվեց։

Կառուցվածք
----------

Պասկալում միացվող մոդուլը ունի հետեւյալ ընդհանուր տեսքը.

```
unit UnitName1;
interface
 ...

implementation
 ...

begin 
 ...
end.

```

Հնարավոր է նաեւ մեկ այլ տարբերակ.

```
unit UnitName2;
interface
 ...

implementation
 ...

initialization
 ...

finalization
 ....

end.

```

Ի տարբերություն գլխավոր ծրագրի, մոդուլի ֆայլը սկսվում է UNIT բանալի բառով, որին հետեւում է մոդուլի անվանումը եւ կետ-ստորակետը։ Ժամանակակից կիրառումները որպես կանոն, պահանջում են, որ մոդուլի անվանումը համընկնի նախնական կոդի ֆայլի անվան հետ, որի մեջ այդ պարունակվում է այդ մոդուլը։ Մոդուլը պարունակում է երեք բաժին՝ ինտերֆեյսի բաժին, իրականացման բաժինը եւ մոդուլի մարմինը։

Ինտերֆեյսի բաժինը առաջինն է, սկսվում է `INTERFACE` բանալի բառով եւ վերջանում է մոդուլի այն տեղում, որտեղ սկսվում է բաժնի իրականացումը կամ մարմինը։

Մոդուլի մարմինը սկսվում է `BEGIN` բանալի բառով։ Մարմինը պարունակում է ծրագրային կոդ, որը մոդուլի բեռնման ժամանակ կատարվում է մեկ անգամ։

Մուդուլը վերջանում է `END` բանալի բառով եւ կետով(.)։

Ծանոթագրություններ
------------------

1. 1 2 3
2. ↑  Kim B. Bruce, Foundations of Object-oriented Languages: Types and Semantics, «MIT Press» — 416, էջեր 416 — 416 էջ, ISBN 9780262025232։
3. ↑  Հանրահայտ ծրագրավորման լեզուների ինդեքս TIOBE Archived 2013-07-02 at the Wayback Machine.(անգլ.)
4. ↑  «The guiding idea was to construct a genuine successor of Pascal meeting the requirements of system engineering, yet also to satisfy my teacher’s urge to present a systematic, consistent, appealing, and teachable framework for professional programming.» — Wirth N. Modula-2 and Oberon (HOPL III)
5. ↑  Wirth N. Recollections about the development of Pascal (HOPL II), 3.3
6. ↑  Jon Udell, Crash of the Object-Oriented Pascals, BYTE, July, 1989.
7. ↑  M. I. Trofimov, The End of Pascal?, BYTE, March, 1990, p. 36.
8. ↑  Why Pascal is Not My Favorite Programming Language
9. ↑  PASCAL: User Manual and Report ISO Pascal Standard Kathleen Jensen and Niklaus Wirth, 4th edition, Springer Verlag New York, Inc. 1974, 1985, 1991
10. ↑  Object-Oriented Extensions to Pascal Archived 2021-06-05 at the Wayback Machine. Technical Committee X3J9, Programming Language Pascal
11. ↑  ISO 7185 Pascal

Արտաքին հղումներ
----------------

* Պասկալ հոդվածը Curlie-ում (ըստ DMOZ-ի)
* Pascal Central Archived 2010-03-10 at the Wayback Machine.(անգլ.)
* Պասկալի աղբյուրները ամբողջ աշխարհում, Ծրագրի մասին կայք
* Հոդված Պասկալի մասին Archived 2007-05-27 at the Wayback Machine. progopedia.ru հանրագիտարանում