«Ինտերպրետատոր»–ի խմբագրումների տարբերություն
Content deleted Content added
չ Ռոբոտ․ Տեքստի ավտոմատ փոխարինում (- , +,, -, +, , - + ) |
|||
Տող 1.
{{Ծրագրի իրականացում}}
Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է, [[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված հրամաններ, առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար
#վերլուծել ({{lang-en|parse}}) [[Ելակետային կոդ|սկզբանկան կոդը]]
#թարգմանել [[Ելակետային կոդ|սկզբանկան կոդը]], ինչ որ միջանկյալ տեսքի և իրականացնել այն։
#Հստակ իրականացնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}}) կոդը՝ կոմպիլյատորի կողմից կազմված, որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս։
Տող 11.
== Կոմպիլյատորների և ինտերպրետատորների համեմատումը ==
[[Պատկեր:Linker.svg|thumb|Կապերի խմբագրիչի
Բարձր մակարդակի լեզուներով գրված ծրագրերը, կամ ուղղակիորեն իրականցվում են ինտերպրետատորի ինչ-որ մի տեսակով, կամ կոմպիլյատորի կողմից ձևափոխվում են [[Machine code|մեքենայական կոդի]]՝ պրոցեսորի համար, որպեսզի այն կատարի։
Չնայած կոմպիլյատորների հիմանկան արդյունքը հարդվերի կողմից գործարկվող մեքենայական կոդն է, դրանց արդյունքը հաճախ կարող է ընդունել միջանկյալ տեսք՝ [[Object code|օբյեկտային կոդ]]({{lang-en| object code }}) անվանմամբ։ Կոմպիլյացվող ծրագիրը սովորաբար օգտագործում է կառուցվող բլոկներ (ֆունկցիաներ) գրադարանում պահված այդպիսի օբյեկտային կոդի մոդուլներ. [[Կապերի խմբագրիչ]]ը ({{lang-en| linker }})օգտագործում է գրադարանային ֆայլերը օբյեկտային ֆայլերի հետ միավորելու համար
Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոքենների ({{lang-en| token}}), երկուսն էլ կարող են գեներացնել վերլուծության ծառ({{lang-en| parse tree}}), և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար, կամ այլ
[[Պատկեր:kaantotulkkaus.png|thumb|upright=1.87 | Կոմպիլյացում և ինտերպրետացում]]
Կոմպիլյատորը փոխակերպում
Մեկ անգամ կոմպիլյացնել և
Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը, քանի դեռ այն լիովին անսխալ է։ Ինտերպրետատորը [[Ծրագրի կատարում|կատարում]]
=== Մշակման ցիկլ ===
Տող 33.
Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր({{lang-en| portable}})։ Այդ փոխակերպումը տեղի է ունենում միայն մեկ անգամ և դրանից հետո նույն բինար ինստրուկցիաները տեղաբաշխում են օգտագործողի մեքենայում, որտեղ այն կարողանում է կատարվել առանց հետգա թարգմանությունների։ [[Խաչաձև կազմարկիչ|Կրոսս կոմպիլյատորներ]]ը կարողանում են գեներացնել բինար կոդ օգտագործողի մեքենայի համար, անգամ եթե այն ունի այլ պրոցոսսոր քան մեքենան, որտեղ կոդը կոմպիլյացվում է։
Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։
=== Էֆեկտիվություն ===
Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է
Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում
Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ)
{| class="wikitable
! Toy [[C (ծրագրավորման լեզու)|C]] expression interpreter
Տող 48.
| <syntaxhighlight lang="C">
// data types for abstract syntax tree
enum _kind { kVar, kConst, kSum, kDiff, kMult, kDiv, kPlus, kMinus, kNot };
struct _variable
struct _constant
struct _unaryOperation
struct _binaryOperation { struct _node *left, *right; };
struct _node {
};
// interpreter procedure
int executeIntExpression(const struct _node *n) {
case kVar: return *n->e.variable.memory;
switch (n->kind) {
case
case
case
▲ leftValue = executeIntExpression(n->e.binary.left);
▲ rightValue = executeIntExpression(n->e.binary.right);
▲ switch (n->kind) {
▲ case kSum: return leftValue + rightValue;
case kPlus: case kMinus: case kNot:
case kDiff: return leftValue - rightValue;▼
▲ case kDiv: if (rightValue == 0)
▲ exception("division by zero"); // doesn't return
case
case kNot:
▲ case kPlus: case kMinus: case kNot:
▲ rightValue = executeIntExpression(n->e.unary.right);
}
▲ switch (n->kind) {
▲ case kMinus: return - rightValue;
▲ }
▲ default: exception("internal error: illegal expression kind");
▲ }
}
</syntaxhighlight>
Տող 96.
=== Ռեգրեսիա ===
[[Ծրագրի կատարում|Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝
== Վարիացիաներ ==
Տող 103.
{{main|Բայթկոդ}}
Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է ({{lang-en| compressed }}) և օպտիմիզացիան ներկայացնում է Լիսպի
=== Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ
Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ
Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) դառնում է պատճառ ավելի շատ վերադիր ծախսերի ({{lang-en|overhead
=== JIT կոմպիլյացիան (Just-in-time compilation) ===
Տող 114.
{{main|JIT կոմպիլյացիան}}
JIT կոմպիլյացիան տեխնալոգիա է, որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, [[ծրագրի կատարման ժամանակ]]։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ '' Ադապտիվ օպտիմիզացիան '' լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն
=== Self-ինտերպրետատոր (Self-interpreter) ===
Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ 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-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։
Տող 127.
* Ինտերպրետատորները հիմանակնում օգտագործում են կատարելու համար հրամանային լեզուներ, և glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( {{lang-en | editor}}) կամ կոմպիլյատորը։
* '''Ինքնաձևափոխվող կոդը''' ( {{lang-en | Self-modifying code }}) կարող է հեշտությամբ իրականցվել ինտերպրետացվող լեզուներում։ Դա վերաբերվում է Լիսպի ինտերպրետացիային և [[Արհեստական բանականություն|արհեստական բանականության]] հետազոտմանը։
* '''Վիրտուալիզացիա'''( {{lang-en | Virtualization }})։''Վիրտուալիզացիան վերաբերվում է ինչ-որ բանի վիրտուալ տարբերակի ստեղծմանը, ներառած վիրտուալ հարդվերի պլատֆորմներ, օպերացիան համակարգեր, [[հիշող սարք]]եր, [[համակարգչային ցանց]]ի ռեսուրսներ։''։[[Մեքենայական կոդ]]ը նախատեսված մեկ հարդվերի ճարտարապետության համար, կարող է աշխատել մեկ ուրշներում, օգտագործոլով վիրտուալ մեքենա։
* '''Ավազաման''' ( {{lang-en | Sandboxing }})։ ''Ավազամանը համակարգչային անվտանգությունում հատուկ մշակված միջոց է, համակարգչային ծրագրերի անվտանգ կատարման համար։''։ Ինտերպրեատատորը կամ վիրտուալ մեքնենան իրականում ստիված չեն կատարել սկզբանական կոդի բոլոր հրամանները, դա մշակվում է։ Մասնավորապես, այն կարող է հրաժարվել կարարել կոդը, որը խախտում է որևէ ապահովության սահմանները։
|