«Ինտերպրետատոր»–ի խմբագրումների տարբերություն

չ
Ռոբոտ․ Տեքստի ավտոմատ փոխարինում (- , +,, -, +, , - + )
չ (Ռոբոտ․ Տեքստի ավտոմատ փոխարինում (- , +,, -, +, , - + ))
{{Ծրագրի իրականացում}}
Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է, [[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված հրամաններ, առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
 
#վերլուծել ({{lang-en|parse}}) [[Ելակետային կոդ|սկզբանկան կոդը]] և ուղղակիորեն կատարել։
#թարգմանել [[Ելակետային կոդ|սկզբանկան կոդը]], ինչ որ միջանկյալ տեսքի և իրականացնել այն։
#Հստակ իրականացնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}}) կոդը՝ կոմպիլյատորի կողմից կազմված, որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս։
 
== Կոմպիլյատորների և ինտերպրետատորների համեմատումը ==
[[Պատկեր:Linker.svg|thumb|Կապերի խմբագրիչի գործընթացը։]]
Բարձր մակարդակի լեզուներով գրված ծրագրերը, կամ ուղղակիորեն իրականցվում են ինտերպրետատորի ինչ-որ մի տեսակով, կամ կոմպիլյատորի կողմից ձևափոխվում են [[Machine code|մեքենայական կոդի]]՝ պրոցեսորի համար, որպեսզի այն կատարի։
 
Չնայած կոմպիլյատորների հիմանկան արդյունքը հարդվերի կողմից գործարկվող մեքենայական կոդն է, դրանց արդյունքը հաճախ կարող է ընդունել միջանկյալ տեսք՝ [[Object code|օբյեկտային կոդ]]({{lang-en| object code }}) անվանմամբ։ Կոմպիլյացվող ծրագիրը սովորաբար օգտագործում է կառուցվող բլոկներ (ֆունկցիաներ) գրադարանում պահված այդպիսի օբյեկտային կոդի մոդուլներ. [[Կապերի խմբագրիչ]]ը ({{lang-en| linker }})օգտագործում է գրադարանային ֆայլերը օբյեկտային ֆայլերի հետ միավորելու համար մեկ գործարկվող ({{lang-en| executable }}) ֆայլում։
 
Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոքենների ({{lang-en| token}}), երկուսն էլ կարող են գեներացնել վերլուծության ծառ({{lang-en| parse tree}}), և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար, կամ այլ միջոցներով)։ Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համակարգերը, այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի ծրագիր, մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականացնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով։
 
[[Պատկեր:kaantotulkkaus.png|thumb|upright=1.87 | Կոմպիլյացում և ինտերպրետացում]]
 
Կոմպիլյատորը փոխակերպում է միանգամից ամբողջ սկզբնական կոդը։ Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր։ Իտերպրետատորը նույնպես փոխակերպում է սկզբանական կոդը, սակայն տող առ տող։ Երբ առաջին տողը արդեն փոխակերպված է, այն միանգամից կատարվում է։
 
Մեկ անգամ կոմպիլյացնել և [[Ծրագրի կատարում|կատարել]] ցանկացած ժամանակ։ Կոմպիլյացվող ծրագիրերն ամեն անգամ չեն կոմպիլյացվում։ Ինտերպրետացվող ծրագրերը ինտերպրետացվում են տող առ տող ամեն անգամ, երբ դրանք [[Ծրագրի կատարում|կատարում]] են։
 
Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը, քանի դեռ այն լիովին անսխալ է։ Ինտերպրետատորը [[Ծրագրի կատարում|կատարում]] է ծրագիրը առաջին տողից սկսած և դադարում է միայն այն դեպքում, երբ հանդիպում է սխալ։
 
=== Մշակման ցիկլ ===
Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր({{lang-en| portable}})։ Այդ փոխակերպումը տեղի է ունենում միայն մեկ անգամ և դրանից հետո նույն բինար ինստրուկցիաները տեղաբաշխում են օգտագործողի մեքենայում, որտեղ այն կարողանում է կատարվել առանց հետգա թարգմանությունների։ [[Խաչաձև կազմարկիչ|Կրոսս կոմպիլյատորներ]]ը կարողանում են գեներացնել բինար կոդ օգտագործողի մեքենայի համար, անգամ եթե այն ունի այլ պրոցոսսոր քան մեքենան, որտեղ կոդը կոմպիլյացվում է։
 
Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։ Այնուամենայնիվ, ինտերպրետացվող սկզբանկան կոդերի տեղափոխումը կախված է ելքային մեքենայից ({{lang-en| target machine}}) իրապես ունենալով համապատասխան ինտերպրտատոր։
 
=== Էֆեկտիվություն ===
Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ փոքր։ Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը։ Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը({{lang-en|edit-interpret-debug }}) հաճախ կարող է լինել շատ ավելի կարճ քան խմբագիր-կոմպիլյացիա-կատարում-դեբագ ({{lang-en| edit-compile-run-debug }}) ցիկլը։
 
Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում ինտերպրետատորը պետք է վերլուծի յուրաքանչյուր հրաման, ամեն անգամ երբ այն կատարվում է և հետո կարի անհրաժեշտ գործողություններ, մինչդեռ կոմիլյացվող կոդը ուղղակի կատարում է գործողություններ, ֆիքսված կոնտեքստում՝ կոմպիլյատորի կողմից սահմանված։ Դա [[Ծրագրի կատարման ժամանակ|կատարման ժամանակ]]ի վերուծությունն է։ Ինտերպրետատորում փոփոխականների հասանելությունը ևս դանդաղ է, քանի որ պահպանման տեղերում իդենտիֆիկատորների մափփինգը({{lang-en| mapping}}) պետք է անել հաճախակի կատարման ժամանակ, այլ ոչ թե [[կոմպիլյացիայի ժամանակ]]։
 
Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ) միջև գոյություն ունեն տարբեր կոմպրոմիսներ։ Որոշ համակարգեր (օրինակ որոշ լիսպեր)թույլատրում են ինտերպրետացնել և կոմպիլյացնել կոդը կանչելով միմյանց և բաժանելով փոփոխականները։ Շատ Ինտերպրետատորներ սկզբնական կոդը չեն կատարում, ինչպես արժե, բայց այն փախակերպում են ինչ-որ ավելի կոմպակտ ներքին տեսքի։ Շատ հիմանական ինտերպրտատորներ բանալի բառերը փոխարինում են մի [[բայթ]] նիշերի ({{lang-en| byte tokens }}) , որոնք կարող են օգտագործվել անցման աղյուսակներում ({{lang-en| jump table}}) ինստրուկցիաների որոնման համար։ Որոշ ինտերպրետատորներ, ձգտում են ավելի բարձր մակարդակի ծրագրերի խտացման՝ օգտագործելով [[բիթ]]-կողմնորոշված(այլ ոչ թե բայթ-կողմնորոշված ) ծրագրերի հիշողության ստրուկրուրաներ, որտեղ նշանների հրամանները հնարավոր է զբաղեցնեն 5 բիթ, անվանապես "16-bit" հաստատնները պահվում են փոփոխական-երկարության կոդում ({{lang-en| variable-length code }}, այն կոդ է, որը ցուցադրում է սկզբնական սիմվոլները փոփոխականի թվերի բիթերով ) պահանջելով 3, 6, 10, կամ 18 բիթ և օպերանդի հասցեն ներառում է <բիթ օֆսեթ> ({{lang-en| bit offset}})։
 
{| class="wikitable collapsed" "
 
! Toy [[C (ծրագրավորման լեզու)|C]] expression interpreter
| <syntaxhighlight lang="C">
// data types for abstract syntax tree
enum _kind { kVar, kConst, kSum, kDiff, kMult, kDiv, kPlus, kMinus, kNot };
struct _variable { int *memory; };
struct _constant { int value; };
struct _unaryOperation { struct _node *right; };
struct _binaryOperation { struct _node *left, *right; };
struct _node {
enum _kind kind;
union _expression {
struct _variable variable;
struct _constant constant;
struct _binaryOperation binary;
struct _unaryOperation unary;
} e;
};
// interpreter procedure
int executeIntExpression(const struct _node *n) {
int leftValue, rightValue;
switch (n->kind) {
case kVar: return *n->e.variable.memory;
case kMinuskConst: return n- rightValue>e.constant.value;
case kSum: case kPluskDiff: case kMinuskMult: case kNotkDiv:
leftValue = executeIntExpression(n->e.binary.left);
rightValue = executeIntExpression(n->e.binary.right);
switch (n->kind) {
case kVarkSum: return leftValue + return *n->e.variable.memoryrightValue;
case kConstkDiff: return leftValue - return n->e.constant.valuerightValue;
case kSumkMult: case kDiff: casereturn kMult:leftValue case* kDiv:rightValue;
case kDiv: if (rightValue == 0)
leftValue = executeIntExpression(n->e.binary.left);
exception("division by zero"); // doesn't return
rightValue = executeIntExpression(n->e.binary.right);
case kSum: return leftValue +/ rightValue;
switch (n->kind) {
}
case kSum: return leftValue + rightValue;
case kPlus: case kMinus: case kNot:
case kDiff: return leftValue - rightValue;
rightValue = executeIntExpression(n->e.unary.right);
case kMult: return leftValue * rightValue;
switch (n->kind) {
case kDiv: if (rightValue == 0)
case kDiffkPlus: return leftValue -+ rightValue;
exception("division by zero"); // doesn't return
case kMinus: return leftValue /- rightValue;
case kNot: } return ! rightValue;
}
case kPlus: case kMinus: case kNot:
default: exception("internal error: illegal expression kind");
rightValue = executeIntExpression(n->e.unary.right);
}
switch (n->kind) {
case kPlus: return + rightValue;
case kMinus: return - rightValue;
case kNot: return ! rightValue;
}
default: exception("internal error: illegal expression kind");
}
}
</syntaxhighlight>
 
=== Ռեգրեսիա ===
[[Ծրագրի կատարում|Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝ թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես [[Մշակիչ|պրոցեսսոր]]ը կարող է կատարել [[մեքենայկան կոդ]]ը ։
 
== Վարիացիաներ ==
{{main|Բայթկոդ}}
 
Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է ({{lang-en| compressed }}) և օպտիմիզացիան ներկայացնում է Լիսպի սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում, այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։
 
=== Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ ===
Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ մոտոցում է, սկզբնական կոդի փոխակերպումը օպտիմալցված աբստրակտ շարահյուսության ծառի, կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն [[JIT-կոմպիլյացիա|դինամիկ]] գեներացնելով սեփական կոդ({{lang-en| native code }} կամ մեքենայական կոդ) ։ Այս մոտեցմամբ նախադասության շարահյուսական վերլուծությունը({{lang-en|parse }}) կատարվում է միայն մեկ անգամ։ [[JIT-կոմպիլյացիա|JIT-կոմպիլյյատերների]] համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ [[Ծրագրի կատարման ժամանակ]] այդ համակարգը ավելի լավ վերլուծություն է կատարում։
 
Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) դառնում է պատճառ ավելի շատ վերադիր ծախսերի ({{lang-en|overhead }}), քան բայթկոդ ինտերպրետատորի դեպքում։
 
=== JIT կոմպիլյացիան (Just-in-time compilation) ===
{{main|JIT կոմպիլյացիան}}
 
JIT կոմպիլյացիան տեխնալոգիա է, որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, [[ծրագրի կատարման ժամանակ]]։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ '' Ադապտիվ օպտիմիզացիան '' լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝ [[Smalltalk]]-ը 1980 թ․-ին։
 
=== Self-ինտերպրետատոր (Self-interpreter) ===
Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ BASIC ինտերպրետատորը գրված BASIC-ով։
 
Եթե լեզվի համար գոյություն չունի կոմպիլյատոր պետք է ինտերպրետացնել, Self-ինտերպրետատորի ստեղծումը պահանջում է լեզվի իրականացում բազային լեզվում({{lang-en|host language }}), այն կարող է լինել ցանկացած ծրագրավորման լեզու կամ [[Ասսեմբլեր լեզու|ասսեմբլեր]]։ Ունենալով առաջին ինտերպրետատորը ինչպիսին դա է, համակարգը բուտստրապպվում է({{lang-en| bootstrapping }}, ծրագրավորման լեզվի կոմպիլյատորի ստեղծման մեթոդ է, երբ կոմպիլյատորի կոդի զգալի մասը ստեղծվում է ելքային լեզվով ({{lang-en| Target language }}))
 
Համակարգչային լեզվի սահմանումը, որպես կանոն իրականցվում է աբստրակտ մեքենայով ({{lang-en | operational semantics }}) կամ մաթեմատիկակն ֆունկցիաներով({{lang-en| denotational semantics}})։ Լեզուները կարող են սահմնավել ինտերպրետատորով, որում բազային լեզվի ({{lang-en| host language }}) սեմանտիկան տրված է։ Self-ինտերպրետատորվ սահմանված լեզուները հիմնավորված չեն (չեն կարող սահմանել լեզուներ), բայց Self-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։
Կարևոր ասպեկտ է Self-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։
 
* Ինտերպրետատորները հիմանակնում օգտագործում են կատարելու համար հրամանային լեզուներ, և glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( {{lang-en | editor}}) կամ կոմպիլյատորը։
* '''Ինքնաձևափոխվող կոդը''' ( {{lang-en | Self-modifying code }}) կարող է հեշտությամբ իրականցվել ինտերպրետացվող լեզուներում։ Դա վերաբերվում է Լիսպի ինտերպրետացիային և [[Արհեստական բանականություն|արհեստական բանականության]] հետազոտմանը։
* '''Վիրտուալիզացիա'''( {{lang-en | Virtualization }})։''Վիրտուալիզացիան վերաբերվում է ինչ-որ բանի վիրտուալ տարբերակի ստեղծմանը, ներառած վիրտուալ հարդվերի պլատֆորմներ, օպերացիան համակարգեր, [[հիշող սարք]]եր, [[համակարգչային ցանց]]ի ռեսուրսներ։''։[[Մեքենայական կոդ]]ը նախատեսված մեկ հարդվերի ճարտարապետության համար, կարող է աշխատել մեկ ուրշներում, օգտագործոլով վիրտուալ մեքենա։
* '''Ավազաման''' ( {{lang-en | Sandboxing }})։ ''Ավազամանը համակարգչային անվտանգությունում հատուկ մշակված միջոց է, համակարգչային ծրագրերի անվտանգ կատարման համար։''։ Ինտերպրեատատորը կամ վիրտուալ մեքնենան իրականում ստիված չեն կատարել սկզբանական կոդի բոլոր հրամանները, դա մշակվում է։ Մասնավորապես, այն կարող է հրաժարվել կարարել կոդը, որը խախտում է որևէ ապահովության սահմանները։