Ինտերպրետատոր

Խնդրում ենք նշել կաղապարի տեղադրման ամսաթիվը 2024-04-25 04:45:20 ֆորմատով

Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն կատարում է,ծրագրավորման կամ սկրիպտավորման լեզուներով գրված համաններ,առանց դրանք նախապես կոմպիլյացնոլով մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար  հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝

# վերլուծել սկզբանկան կոդը  և ուղղակիորեն կատարել:

#թարգմանել սկզբանկան կոդը,ինչ որ միջանկյալ տեսքի և իրականցնել այն:

#Հստակ իրականցնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}}) կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:

Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո կապվում է կատարման ժամանակ և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից({{lang-en| JIT }}կոմպիլյացիայի համակարգի համար):

Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար,դրանք չեն հակասում միմյանց,որովհետև ինտերպրետացվող համկարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք,ինչպես կոմպիլյատորը: "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար:

Կոմպիլյատորների և ինտերպրետատորների համեմատումը 

Կապերի խմբագրիչի  գործընթացը։

Բարձր մակարդակի լեզուներով գրված ծրագրերը,  կամ ուղղակիորեն իրականցվում են ինտերպրետատորի ինչ-որ մի տեսակով, կամ կոմպիլյատորի կողմից ձևափոխվում են մեքենայական կոդի՝ պրոցեսորի համար,որպեսի այն կատարի: 

Չնայած կոմպիլյատորների հիմանկան արդյունքը հարդվերի կողմից գործարկվող մեքենայական կոդն է,դրանց արդյունքը հաճախ կարող է ընդունել միջանկյալ տեսք՝ օբյեկտային կոդ({{lang-en| object code }}) անվանմամբ: Կոմպիլյացվող ծրագիրը սովորաբար օգտագործում է կառուցվող բլոկներ (ֆունկցիաներ) գրադարանում պահված այդպիսի օբյեկտային կոդի մոդուլներ. Լինկերն ({{lang-en| linker }})օգտագործում է գրադարանային ֆայլերը օբյեկտային ֆայլերի հետ միավորելու համար  մեկ գործարկվող ({{lang-en| executable }}) ֆայլում:

Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոկենների ({{lang-en| token}}), երկուսն էլ կարող են գեներացնել վերլուծության ծառ({{lang-en| parse tree}}),և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար,կամ այլ  միջոցներով): Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համկարգերը,այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի  ծրագիր,մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականցնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով:

Կոմպիլյատորը փոխակերպում  է միանգամից ամբողջ սկզբնական կոդը:Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր: Իտերպրետատորը նույնպես փոխակերպում է սկզբանական կոդը,սակայն տող առ տող:Երբ առաջին տողը արդեն փոխակերպված է,այն միանգամից  կատարվում է:

Մեկ անգամ կոմպիլյացնել և  կատարել   ցանկացած ժամանակ:Կոմպիլյացվող ծրագիրերն ամեն անգամ չեն կոմպիլյացվում: Ինտերպրետացվող ծրագրերը ինտերպրետացվում են տող առ տող ամեն անգամ,երբ դրանք կատարում են:

Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը,քանի դեռ այն լիովին անսխալ է: Ինտերպրետատորը կատարում  է ծրագիրը առաջին տողից սկսած և դադարում է միայն այն դեպքում, երբ հանդիպում է սխալ: 

Մշակման ցիկլ

Ծրագրային ապահովման մշակման ցիկլում, ծրագրավորողները սկզբնկան կոդում հաճախակի փոփոխություններ են կատարում։ Կոմպիլյատորի օգտագործման դեպքում, ամեն անգամ երբ սկզբնական կոդը փոխվում է , դրանք պետք է սպասեն կոմպիլյատորին,որպիսի թարգմանի փոխված սկզբնական ֆայելրը ({{lang-en| source file}}), և կապի բոլոր երկուական կոդերի ֆայլերը իրար, հետո ծրագրը կարող է կատարվել։ Ինչքան ծրագիրը մեծ է,այդքան երկար պետք է սպասել։ Ինտերպրետատորի օգտագործման դեպքում ծրագրավորողը սպասում է ավելի քիչ,քանի որ ինտերպրետատորը կոդը թարգմանում է ներկայացնելով այն միջանկյալ տեսքով(կամ ամբողջը չի թարգմանում)։ Հետևությունները դառնում է ակնհայտ,սկզբանակն կոդը պահելուց ({{lang-en| saving}}) և ծրագիրը բեռնելուց({{lang-en| reloading}}) հետո։

Բաշխման սկզբունք

Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր({{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}})։

Toy C expression interpreter

// 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 kConst: return n->e.constant.value; case kSum: case kDiff: case kMult: case kDiv: leftValue = executeIntExpression(n->e.binary.left); rightValue = executeIntExpression(n->e.binary.right); switch (n->kind) { case kSum: return leftValue + rightValue; case kDiff: return leftValue - rightValue; case kMult: return leftValue * rightValue; case kDiv: if (rightValue == 0) exception("division by zero"); // doesn't return return leftValue / rightValue; } case kPlus: case kMinus: case kNot: 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"); } }

Ինտերպրետատորը կարող է օգտագործել նույն լեքսիական անալիզատորը և շարահյուսական վելուծություն, ինչպես կոմպիլյատորը և հետո ինտերպրետացնում է արդյուքը աբստրակտ շարահյուսության ծառի տեսքով({{lang-en| abstract syntax tree }})։

Ռեգրեսիա

Ծրագրի կատարման համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝  թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես պրոցեսսորը կարող է կատարել մեքենայկան կոդը  ։ 

Վարիացիաներ

 Բայթկոդ ինտերպրետատորներ

Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է ({{lang-en| compressed }}) և օպտիմիզացիան ներկայացնում է Լիսպի  սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում,այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով  Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի  (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։

 Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ   

Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ  մոտոցում է, սկզբնական կոդի փոխակերպումը  օպտիմալցված  աբստրակտ շարահյուսության ծառի,  կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն  դինամիկ գեներացնելով սեփական կոդ({{lang-en| native code }} կամ մեքենայական  կոդ) ։ Այս մոտեցմամբ նախադասության  շարահյուսական  վերլուծությունը({{lang-en|parse }}) կատարվում է միայն մեկ անգամ։  JIT-կոմպիլյյատերների համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ  Ծրագրի կատարման ժամանակ այդ համակարգը ավելի լավ վերլուծություն է  կատարում։

Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) դառնում է պատճառ ավելի շատ վերադիր ծախսերի ({{lang-en|overhead }}), քան բայթկոդ ինտերպրետատորի դեպքում։ .

JIT կոմպիլյացիան (Just-in-time compilation)

Հիմնական հոդված՝ JIT կոմպիլյացիան

.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի

.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի

JIT կոմպիլյացիան տեխնալոգիա է,  որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, ծրագրի կատարման ժամանակ։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ Ադապտիվ օպտիմիզացիան  լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն  էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝ Smalltalk-ը 1980թ․-ին։

Self-ինտերպրետատոր (Self-interpreter)

Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ BASIC ինտերպրետատորը գրված   BASIC-ով ։

Եթե լեզվի համար գոյություն չունի կոմպիլյատոր պետք է ինտերպրետացնել, Self-ինտերպրետատորի ստեղծումը պահանջում է լեզվի իրականացում բազային լեզվում(անգլ.՝ host language ), այն կարող է լինել ցանկացած ծրագրավորման լեզու կամ ասսեմբլեր։ Ունենալով առաջին ինտերպրետատորը ինչպիսին դա է, համակարգը բուտստրապպվում է(անգլ.՝ bootstrapping , ծրագրավորման լեզվի կոմպիլյատորի ստեղծման մեթոդ է, երբ կոմպիլյատորի կոդի զգալի մասը ստեղծվում է ելքային լեզվով (անգլ.՝ Target language ))

Համակարգչային լեզվի սահմանումը, որպես կանոն իրականցվում է աբստրակտ մեքենայով (անգլ.՝ operational semantics ) կամ մաթեմատիկակն ֆունկցիաներով(անգլ.՝ denotational semantics)։ Լեզուները կարող են սահմնավել ինտերպրետատորով, որում բազային լեզվի (անգլ.՝ host language ) սեմանտիկան տրված է։ Self-ինտերպրետատորվ սահմանված լեզուները հիմնավորված չեն (չեն կարող սահմանել լեզուներ), բայց Self-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։ Կարևոր ասպեկտ է Self-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։

Հավելվածներ

• Ինտերպրետատորները հիմանակնում օգտագործում են կատարելու համար հրամանային լեզուներ, և glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( անգլ.՝ editor) կամ կոմպիլյատորը ։
• 'Ինքնաձևափոխվող կոդը ( անգլ.՝ Self-modifying code ) կարող է հեշտությամբ իրականցվել ինտերպրետացվող լեզուներում։ Դա վերաբերվում է Լիսպի ինտերպրետացիային և արհեստական բանականության հետազոտմանը։
• Վիրտուալիզացիա( անգլ.՝ Virtualization ):Վիրտուալիզացիան վերաբերվում է ինչ-որ բանի վիրտուալ տարբերակի ստեղծմանը,ներառած վիրտուալ հարդվերի պլատֆորմներ, օպերացիան համակարգեր, հիշող սարքեր, համակարգչային ցանցի ռեսուրսներ։։Մեքենայական կոդը նախատեսված մեկ հարդվերի ճարտարապետության համար, կարող է աշխատել մեկ ուրշներում, օգտագործոլով վիրտուալ մեքենա։
• Ավազաման ( անգլ.՝ Sandboxing ): Ավազամանը համակարգչային անվտանգությունում հատուկ մշակված միջոց է, համակարգչային ծրագրերի անվտանգ կատարման համար։։ Ինտերպրեատատորը կամ վիրտուալ մեքնենան իրականում ստիված չեն կատարել սկզբանական կոդի բոլոր հրամանները, դա մշակվում է։ Մասնավորապես, այն կարող է հրաժարվել կարարել կոդը, որը խախտում է որևէ ապահովության սահմանները:

Հղումներ

Վիքիպահեստն ունի նյութեր, որոնք վերաբերում են «Ինտերպրետատոր» հոդվածին։

• IBM Card Interpreters page at Columbia University
• Theoretical Foundations For Practical 'Totally Functional Programming' 
• Short animation 
• http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-004-computation-structures-spring-2009/lecture-notes/MIT6_004s09_lec11.pdf</nowiki>
  
• https://q3k.org/gentoomen/Programming/Pragmatic%20Programmers/Language%20Implementation%20Patterns.pdf</nowiki>