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

չ
չտողադարձվող բացատը (։Դ Non-breaking space) փոխարինում եմ սովորականով։ oգտվելով ԱՎԲ
չ (չտողադարձվող բացատը (։Դ Non-breaking space) փոխարինում եմ սովորականով։ oգտվելով ԱՎԲ)
{{Ծրագրի իրականացում}}
Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է,[[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված հրամաններ, առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար   հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
 
#վերլուծել ({{lang-en|parse}}) [[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել։
#թարգմանել [[Ելակետային կոդ|սկզբանկան կոդը]], ինչ որ միջանկյալ տեսքի և իրականցնել այն։
#Հստակ իրականցնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}}) կոդը՝ կոմպիլյատորի կողմից կազմված, որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս։
 
Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո [[Կապերի խմբագրիչ|կապվում]]  է կատարման ժամանակ  և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից({{lang-en| [[Just-in-time compilation|JIT]]  }} կոմպիլյացիայի համակարգի համար)։
 
Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար, դրանք չեն հակասում միմյանց, որովհետև ինտերպրետացվող համկարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք, ինչպես կոմպիլյատորը։  "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար։
 
== Կոմպիլյատորների և ինտերպրետատորների համեմատումը  ==
[[Պատկեր: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| 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}})։
 
{| class="wikitable collapsed" "
 
=== Ռեգրեսիա ===
[[Ծրագրի կատարում|Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝   թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես [[Մշակիչ|պրոցեսսոր]]ը կարող է կատարել [[մեքենայկան կոդ]]ը   ։ 
 
== Վարիացիաներ ==
 
===  Բայթկոդ  ինտերպրետատորներ ===
{{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 }}), քան բայթկոդ ինտերպրետատորի դեպքում։
{{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-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։
{{Արտաքին հղումներ}}
* [http://www.columbia.edu/acis/history/interpreter.html IBM Card Interpreters] page at Columbia University
* [http://www.archive.org/download/TheoreticalFoundationsForPracticaltotallyFunctionalProgramming/33429551_PHD_totalthesis.pdf Theoretical Foundations For Practical 'Totally Functional Programming'] 
* [https://www.youtube.com/watch?v=_C5AHaS1mOA 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>