Interpretator (računarstvo)

Interpretator ili interpreter (engl. interpreter), u računarstvu, je program koji izvršava kod napisan u nekom programskom jeziku.

U kompjuterskoj nauci, prevodilac je kompjuterski program koji direktno izvršava, odnosno obavlja, uputstva napisana u programskom ili skript jeziku, bez prethodnog sastavljanja u mašinu jezika programa. Interpretator uglavnom koristi jednu od sledećih strategija za izvršenje programa:

analizira izvorni kod i obavlja svoje ponašanje direktno.
prevodi izvorni kod u neki efikasni međujezik i odmah izvrši to.
izričito izvršava i čuva već kompajlirani kod ^{[traži se izvor]} napravljen od strane kompajlera koji je deo prevodioca sistema.

Rane verzije Lisp programskog jezika i Dartmouth BASIC će biti primeri prve vrste. Perl, Python, MATLAB i Ruby su primeri druge, dok UCSD Pascal je primer treće vrste. Izvori programa su unapred sastavljeni i skladišteni kao mašinski nezavisni kodovi, koji se zatim povezuju u run-time i izvodi ih interpretator ili kompajler (za JIT sistem). Neki sistemi, kao što su Smalltalk, savremene verzije BASIC, Java i drugi mogu da kombinuju dva i tri.

Dok tumačenje i kompilacija su dva glavna sredstva pomoću kojih programski jezici se primenjuju, nisu međusobno isključivi, kao i većina interpretacionih sistema takođe obavljaju prevodilački rad. Izrazi "interpretacioni jezik" ili "sastavljen jezik" znači da je primena tog jezika od strane tumača ili prevodilaca, respektivna. Jezik na visokom nivou je idealno apstrakcija nezavistan od pojedinih implementacija.

Istorija

Prvi prevodilac jezika na visokom nivou bio je Lisp . Lisp je prvi put realizovan 1958. godine Steve Russell na IBM 704 kompjuter . Rasel je čitao John McCarthy's papir, i shvatio ( da John McCarthy's iznenađuje ) da bi Lisp funkcija eval mogla biti realizovana u mašinski kod . [ 2 ] Rezultat je bio radni Lisp prevodilac koji bi se mogao koristiti za pokretanje Lisp programa, ili tačnije, " proceniti Lisp izraz " .

Kompajler verzije prevodilaca

Ilustracija procesa povezivanja. Objekt fajlova i statičke biblioteke su sastavljeni u novu biblioteku

Programi pisani na visokom nivou jezika su ili direktno obavljali neku vrstu prevodioca ili su pretvoreni u mašinski kod od strane kompajlera (i asembler i veznik) za procesor ko treba da izvrši. Dok kompajleri (i monteri) uglavnom proizvode mašinski kod direktno izvršen od računarskog hardvera, oni se često (opciono) mogu proizvesti u srednjem obliku nazvanom objektni kod . Tu je u osnovi specifičan kod iste mašine, ali pojačan sa simbolima, sa imenima i oznakama koje daju izvršni blokovi (ili moduli). Konstrukcioni programi će obično koristiti gradivne blokove (funkcije) da ih čuva u biblioteku takvih modula. Spojnica se koristi za kombinovanje (PRE-made) biblioteke fajlova sa ciljem da se formira u jednu izvršnu datoteku. Fajlovi objekta koji se koriste za generisanje izvršne datoteke se tako često proizvedu u različitim vremenima, a ponekad čak i u različitim jezicima (sposobnost stvaranja istog objekta).

Jednostavni prevodilac napisan u jeziku niskog nivoa (npr asembler) mogu da imaju slične mašinske kodove koji sprovode funkcije jezika na visok nivo, skladišti i izvršava kada funkcija ukazuje na to. Međutim, prevodilac napisan na visokom nivou jezika obično koristi drugačiji pristup, kao što su stvaranje, a zatim analiza, ili generisanje i izvršavanje među rezultate uputstva softverski definisane, ili oboje.

Dakle, oba kompajlera kao i prevodioci uglavnom okrenuti ka izvornom kodu (tekstualni fajlovi) na tokene, kako mogu (ili ne mogu) generišu stablo izvođenja, i tako može generisati hitne instrukcije (za stek mašinu, četvorostruki kod, ili na drugi način). Osnovna razlika je u tome sto prevodilački sistem, uključujući (izgrađena ili odvojeno) linker, generiše samostalnu mašinu kod programa, dok prevodilački sistem obavlja radnje opisane programom na visokom nivou.

Kompiliranje može na taj način skoro sve konverzije iz izvornog kod semantike da prebaci na nivo mašine jednom za svagda (odnosno do program mora da se promeni), dok prevodilac mora da uradi neke od ovog posla konverzije. Međutim, na efikasan način prevodioca, veliki deo prevoda rada (uključujući analizu vrste, i slično) se uračuna i radi samo prvi put kao što je program, modul, funkcija, ili čak izjave, to je prilično slično kako prevodilac radi. Međutim, sastavljen program i dalje radi mnogo brže, u većini slučajeva, delom zato što kompajleri su dizajnirani za optimizaciju koda, i može im se dati dovoljno vremena za to. Ovo naročito važi za jednostavnije jezike na visokom nivou bez (mnogo) dinamičke strukture podataka, provere ili kucanja.

U tradicionalnoj kompilaciji, izvršni izlaz na veznike (.exe fajlove ili .dpl datoteke ili biblioteke) je obično premešten kada radi pod opštim operativnim sistemom, slično kao moduli objektnog koda ali sa tom razlikom što ovo premeštanje vrši dinamičko vreme izvršavanja, odnosno kada program učita izvršenje. S druge strane, on je sastavio i povezao programe za male ugrađene sisteme i obično se statički dodeljuju, često teško kodirani u NOR fleš memoriji, jer često nema srednjeg skladištenja i nema operativnog sistema u tom smislu.

Istorijski, većina tumačkih sistema su imali editor samo-sadržine. Ovo je sve češće i za kompilatore (tada često naziva. IDE), iako su neki programeri voleli da koristite editor po svom izboru i pokrenu kompajler, linker i druge alate ručno. Istorijski, kompajleri jesu prevodioci, jer hardver u to vreme nije mogao da podrži druge prevodioce i tumače koda kao i tipično okruženje vremenski ograničene prednosti tumačenja. ^{[traži se izvor]}

Razvojni ciklus

Tokom razvoja softverskog ciklusa, programeri daju česte promene na izvornom kodu. Kada koristite kompajler, svaki put kada se izvrši izmena u izvornom kodu, oni moraju da čekaju prevodioca da prevede izmenjene izvorne fajlove i da ih poveže sve po binarnom kodu datoteke zajedno pre nego što program može biti pogubljen. Što je veći program, duže je čekanje. Nasuprot tome, programer pomoću prevodioca čini mnogo manje na čekanju, kao prevodilac obično samo treba da prevedete kod (ili ne prevede ga uopšte), što zahteva mnogo manje vremena pre nego što promene mogu biti testirane. Efekti su vidljivi nakon spasavanja izvornog koda i pretovaranja programa. Prirediti kod je generalno manje lako nego otklanjanje grešaka kao uređivanje, prikupljanje i povezivanje jer su sekvencijalni procesi koji treba da se sprovode u pravom redosledu sa odgovarajućim setom komandi. Iz tog razloga, mnogi kompajleri imaju izvršnu pomoć, poznatu kao Marka datoteke i programa. Marku liste fajlova kompajler i linker su komandne linije izvornog koda programa fajlova, ali mogu uzeti jednostavne komandne linije menija ulaza (npr "Make 3") koji bira treću grupu (komplet) instrukcija zatim izdaje komande za kompajler, i vezuje navedene fajlove izvornog koda.

Distribucija

Kompajler pretvara izvorni kod u binarni uputstvom iz konkretne arhitekture procesora, Ova konverzija se vrši samo jednom, na okruženje programera, a nakon toga isti binarni može se podeliti na računar korisnika, gde se može izvršiti bez daljeg prevoda. Krst kompajler može da generiše binarni kod za razumljivost mašine, čak i ako ima drugačiji procesor od mašine u kojoj je sastavio kod. Interpretirani program može da se distribuira kao izvorni kod. Potrebno je da se prevede u svakoj završnoj mašini, koja zahteva više vremena, ali čini distribuciju programa nezavisno od arhitekture mašine. Međutim, prenosivost tumačenja izvornog koda zavisi od meta mašina koje zapravo imaju odgovarajuću ulogu prevodioca. Ako tumač treba da se isporučuje zajedno sa izvorom, ukupni proces instalacije je složeniji nego dostavljanje monolitno izvršne jer je sam interpretator deo onoga što treba da se instalira. Činjenica da tumačenje koda može lako da se pročita i kopira, ljudi mogu biti od interesa za narodna autorska prava. Međutim, različiti sistemi šifrovanja i kodiranja postoje. Isporuka srednjeg koda, kao što je bajtkod, ima sličan efekat na zamagljivanja, ali bajtkod može da se dekodira sa dekoderom ili rastavljanjem.

Efikasnost

Glavni nedostatak prevodilaca je da tumačenje programa obično radi sporije nego da ga sastavi. Razlika u brzini može biti mala ili velika; često reda veličine a ponekad i više. To obično traje duže da pokrenete program prevodioca nego da pokrenete kompajlere ali može uzeti manje vremena da ga prevede od ukupnog vremena potrebnog za sastavljanje i pokretanje. Ovo je posebno važno kod prototipova i testiranja koda kada edit tumačenja-debug ciklus često može biti mnogo kraći nego edit sastavljanja-run-debug ciklusa.

Tumačenje koda je sporije nego kada se prevodi kod, jer prevodilac mora da analizira svaki izjavu u programu svaki put kada se izvršava, a zatim izvrši željenu akciju, dok sastavljeni kod samo obavlja radnje u fiksnom kontekstu da odredi kompilacije. Ova Run-time analiza je poznata kao "tumačenja nad glavom". Pristup varijabli je takođe sporiji kod prevodioca, jer mapiranje identifikatora lokacija za skladištenje mora da se uradi više puta u run-time nego kod kompajliranja.

Postoje razni kompromisi između brzine razvoja kada se koristi prevodilac i brzine izvršavanja kada koristite kompajler. Neki sistemi (kao što su neki Lisp-ovi) omogućavaju tumačenje i sastavljanje koda za pozivanje jedni drugih i da dele promenljive. Mnogi prevodioci ne izvršavaju izvorni kod kako treba, ali ga pretvaraju u još kompaktnu internu formu

Alatka C programskog jezika

// 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");                
    }   
}

Tumač može dobro koristiti isti leksički analizator i analizator kao prevodilac a zatim interpretirati dobijenu apstraktnu sintaksu stabla. Primer definicije tipa podataka za ovo drugo, i alatka tumača za sintakse stabala dobijenih iz C izraza su prikazani u kutiji.

Regresija

Tumačenje ne mogu koristiti kao jedini način izvođenja: iako prevodilac se sam po sebi tumači i direktno izvršava program negde gde je potrebno slaganje medijuma, jer kod se tumači, po definiciji, isto kao kod mašina koje procesor može da izvrši. ^{[traži se izvor]} ^{[traži se izvor]}

Varijacije

Bajtkod prevodioci

Postoji spektar mogućnosti između tumačenja i sastavljanja, u zavisnosti od količine analize izvršene pre nego što se program izvršava. Na primer, Emacs Lisp je sastavljen od bajtkoda, što je komprimovano predstavljanje Lisp izvora, ali nije mašinski kod (i stoga nije vezan za bilo kog hardvera). Ovaj "sastavljen" kod se zatim tumači preko bajtkod prevodioca (sama napisan u C). Prevedeni kod u ovom slučaju je mašinski kod za virtuelnu mašinu, koja se ne sprovodi u hardveru. Isti pristup se koristi sa Fort koda koji se koristi u Open Firmware sistema: izvor jezika je sastavljen u "F" kodu (bajtkod), koji se zatim tumači od strane virtuelne mašine Kontrolna tabela - kod nje nije potrebno da prođe kroz fazu sastavljanja -gde se diktira odgovarajući algoritam, tok kontrole putem prilagođenih tumača na sličan način

Sažetak Sintakse prevodilaca

U spektru između tumačenja i sastavljanja, drugi pristup je da se transformiše izvorni kod u optimalnu apstraktnu sintaksu stabla (ast), a zatim izvrši program koji prati ove strukture stabala, ili ga koristiti za generisanje native koda samo-u-vremenu. [6 ] U ovom pristupu, svaka rečenica treba se analizirati samo jednom. Kao prednost nad bajtkodom, AST drži globalnu programsku strukturu i odnose između izjava (koje je izgubio u predstavljanju bajtkoda), kada komprimovani pruža više kompaktna predstavljanja. ^{[traži se izvor]} Na taj način, koristeći AST je predložen kao bolji srednji format kompajlerima nego kao bajtkod. Takođe, omogućava sistemu da bolje radu analize tokom runtime-a.

Međutim, za prevodioce, jedan AST uzrokuje preko granice više nego bajtkod prevodilac, jer čvorovi koji se odnose na obavljanje sintakse nemaju koristan rad, a manje sekvencijalna reprezentacija (koja zahteva veći broj pokazivača).

Dinamički prevod

Inače, stvaraju razliku između prevodilaca, bajtkod-a prevodioca i kompilacije (JIT), tehnika u kojoj je međuproizvod sastavljen na maternjem mašinskom kodu u runtime-u. Ovo daje efikasnost radi native koda, po ceni od pokretanja vremena i povećane upotrebe memorije kada se prvi put sastavlja bajktkod ili AST. Adaptivna optimizacija je komplementarna tehnika u kojoj prevodilac promoviše program rada i sastavljanja. Obe tehnike se nekoliko decenija, pojavljuju na jezicima kao što je Smalltalk u 1980-ih. ^{[traži se izvor]} U trenutku kompilacije pridobio je pažnju među jezičkim realizatorima u poslednjih nekoliko godina, sa Java, .NET Framework,, većina modernih JavaScript implementacija, i Matlab sada, uključujući JITs

Samostalni interpretator

Samostalni prevodilac je programski jezik napisan u nekom programskom jeziku koji može da se protumači; primer je osnovni prevodilac napisan u BASIC. Samostalni prevodioci su vezani za samoodržavajuće prevodioce. Ako nema, kompajler postoji za jezik da se protumači, da stvara sebi prevodioca i da zahteva primenu jezika u jeziku domaćina (koji može biti još jedan programski jezik). Imajući prvog prevodioca, kao što je ova, sistem je unapređen i nove verzije tumača mogu se razviti u samom jeziku.Donald Knuth je razvio grupu prevodioca za jezik WEB koji je pisan na domaćem jeziku. Definisanje kompjuterskog jezika obično se obavlja u odnosu na apstraktne mašine (tzv operativnih semantika) ili kao matematička funkcija (denotaciona semantika). Jezik može takođe biti definisan interpretatorom u kome je semantika maternjeg jezika data. Definicija jezika od strane sopstvenog prevodioca nije utemeljena (ne može definisati jezik). Ona takođe omogućava prevodiocu da tumači njen izvorni kod, prvi korak ka reflektujućem prevođenju Važna dimenzija u implementaciji sopstvenog prevodioca je da li se karakteristika interpretiranog jezika realizuje sa istim osobinama na maternjem jeziku prevodioca. Što se više karakteristike sprovodi funkcije maternjeg jezika, manje kontrole programer prevodioca ima; drugačije ponašanje za bavljenje broja poplava ne može se realizovati ako aritmetičke operacije delegiraju odgovarajuće operacije u maternjem jeziku. Neki jezici imaju svog odgovarajućeg prevodioca, kao što je Lisp ili Prolog. Mnoga istraživanja o lokalnim prevodiocima su sprovedena na Scheme programskom jeziku, dijalektu Lisp-a. U principu, bilo koja Tjuringova potpunost omogućava pisanje sopstvenog prevodioca. Lisp je takav jezik, jer Lisp programi su liste simbola i drugih lista. XSLT je takav jezik, jer XSLT programi su pisani u XML. Pod-domen meta programiranja je pisanje domena specifičnih jezika (DSLs). Clive Gifford uveo je kvalitet mera samo-prevodioca, limit odnosa vremena provedenog kompjuterskim radom. Ova vrednost ne zavisi od programa koji beže. Knjiga Strukture i tumačenja kompjuterskih programa predstavlja primere meta-kružnih tumačenja za šeme i njegove dijalekte. Drugi primeri jezika samostalnih prevodioca su Forth i Pascal.

Aplikacije

Prevodioci se često koriste za izvršenje komande jezika, i skriptnog jezika, jer svaki operater izvršava u komandnom jeziku obično sa pozivanjem na složene rutine kao što je urednik ili kompajler.
Samo-modifikujući kod može lako biti realizovan . Ovo se odnosi na poreklo tumačenja u Lisp i istraživanja veštačke inteligencije.
Virtuelizacija. Mašinski kod namenjen jednoj hardverskoj arhitekturi može se pokrenuti na drugom koristeći virtuelnu mašinu, što je u suštini bio prevodilac.
Sandboxing: Tumač ili virtuelna mašina nije primoran da zapravo izvršava sva uputstva izvorni kod je obrađuje. Konkretno, to može da odbije da izvrši kod koji prekrši bilo bezbednosne ograničenja se rade pod.

Prevodilac bušene kartice

Termin "prevodilac" često poziva komandu jedinice opreme da čitaju bušene kartice i štampa likove u ljudskom obliku čitljive na kartici. IBM-550 Brojni prevodilac i IBM-557 Abecedni prevodioci su tipični primeri iz 1930. i 1954. godine.

Vidi još

Napomene i reference

^ U tom smislu, procesor je prevodilac, instrukcija mašine.
^ Prema onome što je prijavljeno od strane Paul Graham y Hackers & Painters, str. 185 McCarthy je rekao: "Steve Russell je rekao, vidi, zašto ne bih program ovu ... i ja sam mu rekao, ho, ho, vi ste pobrkali teoriju sa praksom, ovo je namenjeno za čitanje, ne za računarstvo. Ali on je otišao i uradio to. On sastavio u svom radu u IBM 704 mašinski kod, fiksiranje greške, a onda je reklamirao ovo kao Lisp prevodilac. Dakle, u tom trenutku Lisp je imao u suštini oblik koji ima danas ... "
^ "Why was the first compiler written before the first interpreter?". Ars Technica. Pristupljeno 9 November 2014.
^ Theodore H. Romer, Dennis Lee, Geoffrey M. Voelker, Alec Wolman, Wayne A. Wong, Jean-Loup Baer, Brian N. Bershad, and Henry M. Levy, ^{[traži se izvor]} The Structure and Performance of Interpreters
^ Terence Parr, Johannes Luber, ^{[traži se izvor]} The Difference Between Compilers and Interpreters
^ AST intermediate representations, Lambda the Ultimate forum
^ A Tree-Based Alternative to Java Byte-Codes, Thomas Kistler, Michael Franz
^ Surfin' Safari - Blog Archive » Announcing SquirrelFish. Webkit.org (2008-06-02). Pristupljeno 2013-08-10.
^ L. Deutsch, A. Schiffman, Efficient implementation of the Smalltalk-80 system, Proceedings of 11th POPL symposium, 1984.

Spoljašnje veze

IBM Prevodioci stranica na Kolumbijskom univerzitetu
Teorijske osnove za praktičnu funkcionalnost programiranja(Poglavlje 7), posebna Doktorska disertacija rešavanja problema formalizovanja šta je prevodilac
Kratka animacija objašnjava ključnu konceptualnu razliku između tumača i prevodioca