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

Content deleted Content added

Գծային

19:50, 7 Դեկտեմբերի 2015-ի տարբերակ

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

վերլուծել (անգլ.՝ parse) սկզբանկան կոդը և ուղղակիորեն կատարել:
թարգմանել սկզբանկան կոդը, ինչ որ միջանկյալ տեսքի և իրականցնել այն:
Հստակ իրականցնել պահպանված նախակոմպիլյացված(անգլ.՝ precompiled) կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:

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

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

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

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

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

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

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

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

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

Մշակման ցիկլ

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

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

Կոմպիլյատորը սկզբնական կոդը փոխակերպում է բինար ինստրուկցիաների, հատուկ պրոցեսսորի համար, դարձնելով այն ավելի քիչ դյուրակիր(անգլ.՝ portable)։ Այդ փոխակերպումը տեղի է ունենում միայն մեկ անգամ և դրանից հետո նույն բինար ինստրուկցիաները տեղաբաշխում են օգտագործողի մեքենայում, որտեղ այն կարողանում է կատարվել առանց հետգա թարգմանությունների։ Կրոսս կոմպիլյատորները կարողանում են գեներացնել բինար կոդ օգտագործողի մեքենայի համար, անգամ եթե այն ունի այլ պրոցոսսոր քան մեքենան, որտեղ կոդը կոմպիլյացվում է։

Ինտերպրետացվող ծրագրերը կարող են բաշխվել սկզբնական կոդի տեսքով։ Այն պետք է թարգմանված լինի յուրաքանչյուր վերջնական մեքենայում, որը շատ ժամանկակ է տևում, բայց ծրագիրը տեղաբաշխում է անկախ մեքենայի ճարտարապետությունից։ Այնուամենայնիվ, ինտերպրետացվող սկզբանկան կոդերի տեղափոխումը կախված է ելքային մեքենայից (անգլ.՝ target machine) իրապես ունենալով համապատասխան ինտերպրտատոր։

Էֆեկտիվություն

Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ փոքր։ Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը։ Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը(անգլ.՝ edit-interpret-debug ) հաճախ կարող է լինել շատ ավելի կարճ քան խմբագիր-կոմպիլյացիա-կատարում-դեբագ (անգլ.՝ edit-compile-run-debug ) ցիկլը։

Կոդի ինտերպրետացումը կատարվում է ավելի դանդաղ է, քան կոմպիլյացվող կոդի կատարումը, քանի որ ծրագրում ինտերպրետատորը պետք է վերլուծի յուրաքանչյուր հրաման, ամեն անգամ երբ այն կատարվում է և հետո կարի անհրաժեշտ գործողություններ, մինչդեռ կոմիլյացվող կոդը ուղղակի կատարում է գործողություններ, ֆիքսված կոնտեքստում՝ կոմպիլյատորի կողմից սահմանված։ Դա կատարման ժամանակի վերուծությունն է։ Ինտերպրետատորում փոփոխականների հասանելությունը ևս դանդաղ է, քանի որ պահպանման տեղերում իդենտիֆիկատորների մափփինգը(անգլ.՝ mapping) պետք է անել հաճախակի կատարման ժամանակ, այլ ոչ թե կոմպիլյացիայի ժամանակ։

Մշակման արագության(երբ օգտագործում են ինտերպրետատոր) և կատարման արագության (երբ օգտագործում են կոմպիլյատորներ) միջև գոյություն ունեն տարբեր կոմպրոմիսներ։ Որոշ համակարգեր (օրինակ որոշ լիսպեր)թույլատրում են ինտերպրետացնել և կոմպիլյացնել կոդը կանչելով միմյանց և բաժանելով փոփոխականները։ Շատ Ինտերպրետատորներ սկզբնական կոդը չեն կատարում, ինչպես արժե, բայց այն փախակերպում են ինչ-որ ավելի կոմպակտ ներքին տեսքի։ Շատ հիմանական ինտերպրտատորներ բանալի բառերը փոխարինում են մի բայթ նիշերի (անգլ.՝ byte tokens ) , որոնք կարող են օգտագործվել անցման աղյուսակներում (անգլ.՝ jump table) ինստրուկցիաների որոնման համար։ Որոշ ինտերպրետատորներ, ձգտում են ավելի բարձր մակարդակի ծրագրերի խտացման` օգտագործելով բիթ-կողմնորոշված(այլ ոչ թե բայթ-կողմնորոշված ) ծրագրերի հիշողության ստրուկրուրաներ, որտեղ նշանների հրամանները հնարավոր է զբաղեցնեն 5 բիթ, անվանապես "16-bit" հաստատնները պահվում են փոփոխական-երկարության կոդում (անգլ.՝ variable-length code , այն կոդ է, որը ցուցադրում է սկզբնական սիմվոլները փոփոխականի թվերի բիթերով ) պահանջելով 3, 6, 10, կամ 18 բիթ և օպերանդի հասցեն ներառում է <բիթ օֆսեթ> (անգլ.՝ 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");                
    }   
}

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

Ռեգրեսիա

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

Վարիացիաներ

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

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

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

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

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

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

Պատկեր:Compile.PNG

.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 ): Ավազամանը համակարգչային անվտանգությունում հատուկ մշակված միջոց է, համակարգչային ծրագրերի անվտանգ կատարման համար։։ Ինտերպրեատատորը կամ վիրտուալ մեքնենան իրականում ստիված չեն կատարել սկզբանական կոդի բոլոր հրամանները, դա մշակվում է։ Մասնավորապես, այն կարող է հրաժարվել կարարել կոդը, որը խախտում է որևէ ապահովության սահմանները:

Հղումներ

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

@@ Տող 2. / Տող 2. @@
 Ինտերպրետատորը ծրագիր է, որը ուղղակիորեն [[Ծրագրի կատարում|կատարում]] է,[[Ծրագրավորման լեզու|ծրագրավորման]] կամ սկրիպտավորման լեզուներով գրված հրամաններ,առանց դրանք նախապես [[Կոմպիլայացիա|կոմպիլյացնոլով]] մեքենայական լեզվի ծրագրի։ ինտերպրետատորը ծրագրի կատարման համար  հիմանակնաում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
-#վերլուծել ({{lang-en|parse}})  [[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել:
+#վերլուծել ({{lang-en|parse}}) [[Ելակետային կոդ|սկզբանկան կոդը]]  և ուղղակիորեն կատարել:
 #թարգմանել [[Ելակետային կոդ|սկզբանկան կոդը]], ինչ որ միջանկյալ տեսքի և իրականցնել այն:
-#Հստակ իրականցնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}})  կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:
+#Հստակ իրականցնել պահպանված նախակոմպիլյացված({{lang-en| precompiled}}) կոդը՝ կոմպիլյատորի կողմից կազմված,որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս:
 Սկզբնական ծրագրերը կոմպիլյացվում են նախապես և մեքենայում պահվում որպես անկախ կոդ, որը հետո [[Կապերի խմբագրիչ|կապվում]] է կատարման ժամանակ և իրականացվում ինտերպրետատորի և/կամ կոմպիլյատորի կողմից({{lang-en| [[Just-in-time compilation|JIT]] }} կոմպիլյացիայի համակարգի համար):
 Չնայած ինտերպրետացիան և կոմպիլյացիան համարվում են երկու հիմանական միջոց ծրագրավորման լեզուների իրականցման համար,դրանք չեն հակասում միմյանց,որովհետև ինտերպրետացվող համկարգերի մեծ մասը կատարում է նաև թարգմանչական աշխատանք, ինչպես կոմպիլյատորը: "Ինտերպրետացվող լեզու" կամ "կոմպիլյացվող լեզու" տերմինները նշանակում են որ տվյալ լեզվի իրականցումը տեղի է ունենում ինտերպրետատորի կամ կոմպիլյատորի միջոցով՝ համապատասխանաբար:
 == Կոմպիլյատորների և ինտերպրետատորների համեմատումը ==
@@ Տող 20. / Տող 18. @@
 Երկուսն էլ՝ կոմպիլյատորները և ինտերպրետատորները հիմնականում սկզբնական կոդը վերածում են թոքենների ({{lang-en| token}}), երկուսն էլ կարող են գեներացնել վերլուծության ծառ({{lang-en| parse tree}}),և երկուսն էլ կարող են գեներացնել անմիջական հրահանգներ (ստեկային մեքենայի համար,կամ այլ  միջոցներով): Հիմնական տարբերությունը այն է, որ կոմպիլյացվող համկարգերը,այդ թվում լինկերը, գեներացնում են ակախ գործող մեքենայական կոդի  ծրագիր, մինչ դեռ ինտերպրետացվող համակարգերը դրա փոխարեն իրականցնում են գործողություններ նկարագրված բարձր մակարդակի լեզուներով:
+[[File:kaantotulkkaus.png|thumb|upright=1.87 | Կոմպիլյացում և ինտերպրետացում]]
+Կոմպիլյատորը փոխակերպում  է միանգամից ամբողջ սկզբնական կոդը:Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր: Իտերպրետատորը նույնպես փոխակերպում է սկզբանական կոդը,սակայն տող առ տող:Երբ առաջին տողը արդեն փոխակերպված է,այն միանգամից  կատարվում է:
-[[File:kaantotulkkaus.png|thumb|upright=1.87 | Կոմպիլյացում և ինտերպրետացում ]]
-Կոմպիլյատորը փոխակերպում  է միանգամից ամբողջ սկզբնական կոդը:Արդյունքը ստացվում է մեկ կամ մի քանի օբյեկտային կոդի ֆայլեր: Իտերպրետատորը նույնպես փոխակերպում  է սկզբանական կոդը,սակայն տող առ տող:Երբ առաջին տողը արդեն փոխակերպված է,այն միանգամից  կատարվում է:
 Մեկ անգամ կոմպիլյացնել և  [[Ծրագրի կատարում|կատարել]]   ցանկացած ժամանակ:Կոմպիլյացվող ծրագիրերն ամեն անգամ չեն կոմպիլյացվում: Ինտերպրետացվող ծրագրերը ինտերպրետացվում են տող առ տող ամեն անգամ,երբ դրանք [[Ծրագրի կատարում|կատարում]] են:
 Կոմպիլյաորը չի թույլատրում գործարկել ծրագիրը,քանի դեռ այն լիովին անսխալ է: Ինտերպրետատորը [[Ծրագրի կատարում|կատարում]]  է ծրագիրը առաջին տողից սկսած և դադարում է միայն այն դեպքում, երբ հանդիպում է սխալ:
 === Մշակման ցիկլ ===
 Ծրագրային ապահովման մշակման ցիկլում, ծրագրավորողները սկզբնկան կոդում հաճախակի փոփոխություններ են կատարում։ Կոմպիլյատորի օգտագործման դեպքում, ամեն անգամ երբ սկզբնական կոդը փոխվում է , դրանք պետք է սպասեն կոմպիլյատորին,որպիսի թարգմանի փոխված սկզբնական ֆայելրը ({{lang-en| source file}}), և [[Կապերի խմբագրիչ|կապի]] բոլոր երկուական կոդերի ֆայլերը իրար, հետո ծրագրը կարող է կատարվել։ Ինչքան ծրագիրը մեծ է,այդքան երկար պետք է սպասել։ Ինտերպրետատորի օգտագործման դեպքում ծրագրավորողը սպասում է ավելի քիչ,քանի որ ինտերպրետատորը կոդը թարգմանում է ներկայացնելով այն միջանկյալ տեսքով(կամ ամբողջը չի թարգմանում)։ Հետևությունները դառնում է ակնհայտ,սկզբանակն կոդը պահելուց ({{lang-en| saving}}) և ծրագիրը բեռնելուց({{lang-en| reloading}}) հետո։
 === Բաշխման սկզբունք ===
@@ Տող 45. / Տող 36. @@
 === Էֆեկտիվություն ===
-Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է  դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ  փոքր։Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց  դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը ։  Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը({{lang-en|edit-interpret-debug }}) հաճախ կարող է լինել շատ ավելի կարճ քան խմբագիր-կոմպիլյացիա-կատարում-դեբագ ({{lang-en| edit-compile-run-debug }}) ցիկլը։
+Հիմանականում ինտերպրետատորի թերությունը հանդիսանում է այն, որ ինտերպրետատորը ծրագիրը կատարում է  դանդաղ, քան եթե այն կոմպիլյացված լիներ։ Արագության փոփոխությունը կարող է լինել մեծ կամ  փոքր։ Ինտերպրետատորի ներքևի ծրագրը աշխատացնելու համար, այն հիմանկանում զբաղեցնում է երկար ժամանակ, քան կոմպիլյացված ծրագրն աշխատացնելը, բայց  դա ինտերպրետացնելու համար այն կարող է զբաղեցնել քիչ ժամանակ, քան դա կոմպյացնելու և աշխատացնելու ընդհանուր ժամանակը։  Սա հատկապես կարևոր է, երբ նախատիպավորվում և տեստավորվում է կոդը, երբ խմբագիր-ինտերպրետատոր-դեբագ ցիկլը({{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" "
@@ Տող 101. / Տող 91. @@
 </syntaxhighlight>
 |}
 Ինտերպրետատորը կարող է օգտագործել նույն [[Լեքսիկական վերլուծություն|լեքսիական անալիզատորը]] և շարահյուսական վելուծություն, ինչպես կոմպիլյատորը և հետո ինտերպրետացնում է արդյուքը աբստրակտ շարահյուսության ծառի տեսքով({{lang-en| abstract syntax tree }})։
-[[File:building_blocks.png|thumb|center|upright=2.0| Կոմպիլյացում և ինտերպրետացում ]]
+[[File:building_blocks.png|thumb|center|upright=2.0| Կոմպիլյացում և ինտերպրետացում]]
 === Ռեգրեսիա ===
-[[Ծրագրի կատարում | Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել  միակ մեթոդ՝  թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես [[Մշակիչ|պրոցեսսոր]]ը կարող է  կատարել [[մեքենայկան կոդ]]ը  ։
+[[Ծրագրի կատարում|Ծրագրի կատարման]] համար ինտերպրետացիան չի կարող օգտագործվել միակ մեթոդ՝  թեև ինտերպրետատորը կարող է ինքն իրեն ինտերպրետացնել և այլն, ծրագրի անմիջական կատարման համր անհրաժեշտ է ստեկի ներքևի ինչ որ հատված, ինչպես [[Մշակիչ|պրոցեսսոր]]ը կարող է կատարել [[մեքենայկան կոդ]]ը  ։
 == Վարիացիաներ ==
@@ Տող 119. / Տող 104. @@
 Ինտերպրետացիայի և կոմպիլյացիայի միջև կան հնարավորությունների ամբողջ սպեկտոր, կախված կատարված վերլուծությունների քանակից՝ մինչև ծրագրի կատարումը։ Օրինակ Emacs Lisp-ը կոմպիլյացնում է բայթկոդը, որը չափազանց խտացված է ({{lang-en| compressed }}) և օպտիմիզացիան ներկայացնում է Լիսպի  սկզբանական, բայց ոչ մեքքենայական կոդ։ Այդ <կոմպիլյացված> կոդը հետո ինտերպրետացվում է բայթկոդ ինտերպրետատորով։ Այս դեպքում կոմպիլյացված կոդը մեքենայական կոդ է վիրտուալ մեքենայի համար, որը իրականցվում ոչ թե հարդվերում,այլ ինտերպրետատորի բայթկոդում։ Նույն մոտեցումը օգտագործվում է Forth կոդի դեպքում օգտգերծելով  Open Firmware համակարգում՝ սկազբանկան լեզուն կոմպլյացվում է <F code>-ի  (բայթկոդ), որը հետո ինտերպրետացվում է վիրտուալ մեքենայում։
 === Աբստրակտ շարահյուսության ծառ Ինտերպրատատորներ   ===
-Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ  մոտոցում է, սկզբնական կոդի փոխակերպումը  օպտիմալցված  աբստրակտ շարահյուսության ծառի,  կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն  [[JIT-կոմպիլյացիա|դինամիկ]] գեներացնելով սեփական կոդ({{lang-en| native code }} կամ մեքենայական  կոդ) ։ Այս մոտեցմամբ նախադասության  շարահյուսական  վերլուծությունը({{lang-en|parse }})  կատարվում է միայն մեկ անգամ։  [[JIT-կոմպիլյացիա|JIT-կոմպիլյյատերների]] համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ  [[Ծրագրի կատարման ժամանակ]] այդ համակարգը ավելի լավ վերլուծություն է  կատարում։
+Ինտերպրետացիայի և կոմպիլյացիայի միջև, այլ  մոտոցում է, սկզբնական կոդի փոխակերպումը  օպտիմալցված  աբստրակտ շարահյուսության ծառի,  կոմպիլյացնելով ծրագիրը այդ ծառի կառուցվածքին, կամ օգտագործում է այն  [[JIT-կոմպիլյացիա|դինամիկ]] գեներացնելով սեփական կոդ({{lang-en| native code }} կամ մեքենայական  կոդ) ։ Այս մոտեցմամբ նախադասության  շարահյուսական  վերլուծությունը({{lang-en|parse }}) կատարվում է միայն մեկ անգամ։  [[JIT-կոմպիլյացիա|JIT-կոմպիլյյատերների]] համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) հանդիսանում է ավելի լավ միջանկյալ ձևաչափ, քան բայթկոդը։ Բացի այդ  [[Ծրագրի կատարման ժամանակ]] այդ համակարգը ավելի լավ վերլուծություն է  կատարում։
 Սակայն, ինտերպրետատորների համար աբստրակտ շարահյուսության ծառը ({{lang-en|AST }}) դառնում է պատճառ ավելի շատ վերադիր ծախսերի ({{lang-en|overhead  }}), քան բայթկոդ ինտերպրետատորի դեպքում։
 === JIT կոմպիլյացիան (Just-in-time compilation) ===
-[[File:Compile.PNG|thumb|upright=1.87 |.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի  ]]
+[[File:Compile.PNG|thumb|upright=1.87 |.NET կոպիլյատորով սկզբնական կոդը կոմպիլայցվում է ՛՛exe՛՛-ի կամ ՛՛dll՛՛-ի]]
 {{main|JIT կոմպիլյացիան}}
-JIT կոմպիլյացիան տեխնալոգիա է,  որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, [[ծրագրի կատարման ժամանակ]]։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ '' Ադապտիվ օպտիմիզացիան '' լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն  էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝  [[Smalltalk]]-ը 1980թ․-ին։
+JIT կոմպիլյացիան տեխնալոգիա է,  որը բարձրացնում է ծրագրային համակարգերի արդյունավետությունը, օգտագործելով բայթկոդ, կոմպիլյացնում է այն մեքենայական կոդի կամ այլ ձևաչափի, [[ծրագրի կատարման ժամանակ]]։ Դա տալիս է էֆեկտիվություն սեփական կոդը աշխատեցնելիս, գործարկաման ժամանակի հաշվին և ավելացնում է հիշողության օգտագործումը երբ բայթկոդը կամ աբստրակտ շարահյուսության ծառը սկզբում կոմպիլյացվում են։ '' Ադապտիվ օպտիմիզացիան '' լրացուցիչ մեթոդ է, որում ինտերպրետատորը ուրվագծում է կատարվող ծրագիրը և կոմպիլյացնում է սեփական կոդում, առավել հաճախակի կատարվող մասերը։ Երկու մեթոդներն  էլ հին են, հայտնվել են այնպիսի լեզուներում ինչպիսին է ՝ [[Smalltalk]]-ը 1980թ․-ին։
 === Self-ինտերպրետատոր (Self-interpreter) ===
-Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ  BASIC ինտերպրետատորը գրված   BASIC-ով ։
+Self-ինտերպրետատորը ծրագրավորման լեզվի ինտերպրետատոր է, գրված ծրագրավորման լեզվով, որը կարող է ինտերպրետացնել ինքն իրեն, օրինակ BASIC ինտերպրետատորը գրված   BASIC-ով։
-Եթե լեզվի համար գոյություն չունի կոմպիլյատոր պետք է  ինտերպրետացնել, Self-ինտերպրետատորի ստեղծումը պահանջում է լեզվի իրականացում բազային լեզվում({{lang-en|host language }}), այն կարող է լինել ցանկացած ծրագրավորման լեզու կամ [[Ասսեմբլեր լեզու|ասսեմբլեր]]։ Ունենալով առաջին ինտերպրետատորը ինչպիսին դա է, համակարգը բուտստրապպվում է({{lang-en| bootstrapping }}, ծրագրավորման լեզվի կոմպիլյատորի ստեղծման մեթոդ է, երբ կոմպիլյատորի կոդի զգալի մասը ստեղծվում է ելքային լեզվով ({{lang-en| Target language }}))
+Եթե լեզվի համար գոյություն չունի կոմպիլյատոր պետք է ինտերպրետացնել, 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-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք  նույն առանձնահատկություն՝ իրականցվող  ինտերպրետատորի բազային լեզվում։
+Համակարգչային լեզվի սահմանումը, որպես կանոն իրականցվում է աբստրակտ մեքենայով ({{lang-en | operational semantics }}) կամ մաթեմատիկակն ֆունկցիաներով({{lang-en| denotational semantics}})։ Լեզուները կարող են սահմնավել ինտերպրետատորով, որում բազային լեզվի ({{lang-en| host language  }}) սեմանտիկան տրված է։ Self-ինտերպրետատորվ սահմանված լեզուները հիմնավորված չեն (չեն կարող սահմանել լեզուներ), բայց Self-ինտերպրետատորը ընթերցողին ներկայացնում է լեզվի արտայհայտչությունը և էլեգանտությունը։ Դա նաև թույլ է տալիս թարգմանչին ինտերպրետացնել իր սկզբնական կոդը, առաջին քայլը ուղվելով ինտերպրետացիայի արտացոլմանը։
+Կարևոր ասպեկտ է Self-ինտերպրետատորի իրականացումը՝ ինտերպրետացվող լեզվի առանձնահատկությունը հադիսանում է արդյո՞ք նույն առանձնահատկություն՝ իրականցվող ինտերպրետատորի բազային լեզվում։
 == Հավելվածներ ==
-* Ինտերպրետատորները հիմանակնում օգտագործում են  կատարելու համար հրամանային լեզուներ,  և  glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( {{lang-en | editor}})  կամ կոմպիլյատորը  ։
+* Ինտերպրետատորները հիմանակնում օգտագործում են կատարելու համար հրամանային լեզուներ, և glue լեզուներ, քանի որ յուրաքանչյուր օպերատոր կատարվում է հրամանային լեզվում, դա հիմանկանում կանչում է համալիր ենթածրագիր, այնպիսին ինչպիսին է խմբագիրը ( {{lang-en | editor}}) կամ կոմպիլյատորը։
 * '''Ինքնաձևափոխվող կոդը''' ( {{lang-en | Self-modifying code }}) կարող է հեշտությամբ իրականցվել ինտերպրետացվող լեզուներում։ Դա վերաբերվում է Լիսպի ինտերպրետացիային և [[Արհեստական բանականություն|արհեստական բանականության]] հետազոտմանը։
 * '''Վիրտուալիզացիա'''( {{lang-en | Virtualization }}):''Վիրտուալիզացիան վերաբերվում է ինչ-որ բանի վիրտուալ տարբերակի ստեղծմանը,ներառած վիրտուալ հարդվերի պլատֆորմներ, օպերացիան համակարգեր, [[հիշող սարք]]եր, [[համակարգչային ցանց]]ի ռեսուրսներ։''։[[Մեքենայական կոդ]]ը նախատեսված մեկ հարդվերի ճարտարապետության համար, կարող է աշխատել մեկ ուրշներում, օգտագործոլով վիրտուալ մեքենա։
@@ Տող 158. / Տող 135. @@
 * [http://www.archive.org/download/TheoreticalFoundationsForPracticaltotallyFunctionalProgramming/33429551_PHD_totalthesis.pdf Theoretical Foundations For Practical 'Totally Functional Programming']
 * [http://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><br>
+* 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><br>