Interpreter

Interpreter

Ein Interpreter (im Sinne der Softwaretechnik) ist ein Computerprogramm, das einen Programm-Quellcode im Gegensatz zu Assemblern oder Compilern nicht in eine auf dem System direkt ausführbare Datei umwandelt, sondern den Quellcode einliest, analysiert und ausführt. Die Analyse des Quellcodes erfolgt also zur Laufzeit des Programms.

Der größte Nachteil der Interpretersprachen ist die im Vergleich zu compilierten Programmen deutlich langsamere Ausführungsgeschwindigkeit. Reine Interpreter lesen und analysieren den Quellcode eines Programmes und führen dann die entsprechenden Aktionen aus. Dies ist im Vergleich zu Compilersprachen, bei denen das Programm vor seiner Ausführung in Maschinencode übersetzt wird, der dann vom Prozessor direkt ausgeführt wird, sehr zeitaufwändig. Der Vorteil liegt darin, dass reine Interpreter auf jeder Rechnerarchitektur lauffähig sind, wenn der Quellcode des Interpreters dort übersetzt werden kann.

Inhaltsverzeichnis

Geschwindigkeitssteigerungen

Eine Kompromisslösung ist ein Just-in-time-Compiler (JIT-Compiler), bei dem das Programm erst zur Laufzeit, jedoch direkt in Maschinencode übersetzt wird. Danach wird der übersetzte Code direkt vom Prozessor ausgeführt. Durch Zwischenspeicherung des Maschinencode müssen mehrfach durchlaufene Programmteile nur einmal übersetzt werden. Auch ermöglicht der JIT-Compiler eine stärkere Optimierung des Binärcodes. Allerdings sind solche Interpreter natürlich nur auf einer bestimmten Rechnerarchitektur lauffähig, weil sie Maschinencode für diese Architektur erzeugen.

Eine weitere Zwischenstufe sind Bytecode-Interpreter. Dabei wird der Quelltext (vorab oder zur Laufzeit) in einen einfachen Zwischencode übersetzt, der dann von einem Interpreter, auch häufig als virtuelle Maschine bezeichnet, ausgeführt wird.

Und eine weitere Zwischenstufe besteht darin, Befehle zum Eingabezeitpunkt in leichter decodierbare Tokens umzuwandeln, die aber bei (List-)Ausgabe wieder in Klartext zurückgewandelt werden.

Interpretersprachen

Bekannte Interpretersprachen sind APL, BASIC, FORTH, Perl, Python, Ruby, PHP und viele andere. Auch die Skriptsprachen (wie z. B. JavaScript) können zu den Interpretersprachen gezählt werden.

Bekannte Programmiersprachen, die üblicherweise in Bytecode übersetzt werden, sind Java, C#, Perl und Python.

Für manche Sprachen (etwa Smalltalk) gibt es je nach Anbieter Interpreter, Bytecode-Interpreter, JIT-Compiler oder Compiler in andere Sprachen (beispielsweise nach C oder .NET).

Der Übergang zwischen reinen Interpretern und reinen Compilern ist fließend.

Ein einfacher Interpreter

Folgendes in der Programmiersprache C implementierte Programm stellt einen Interpreter für eine sehr einfache Programmiersprache dar. Die hiermit definierte Programmiersprache unterstützt keinerlei Kontrollstrukturen, speichert allerdings verschiedene Werte unter den vom Programmierer definierten Variablennamen.

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
typedef struct
{
        char* varname;
        char* value;
} var;
 
var*   variables;
int            var_cnt         = 0;
 
int putvar( char* varname, char* value )
{
        int            i;
 
        strupr( varname );
 
        /* Suche Speicherplätze und fülle mit neuen Wert,
         falls schon vorhanden */
        for( i = 0; i < var_cnt; i++ )
        {
                if( strcmp( variables[i].varname, varname ) == 0 )
                {
                        if( variables[i].value != (char*) NULL )
                                free( variables[i].value );
 
                        variables[i].value = strdup( value );
                        return 0;
                }
 
        }
 
        /* Neue Variable anlegen */
        if( var_cnt == 0 )
                variables = (var*)malloc( sizeof( var ) );
        else
                variables = (var*)realloc( (var*) variables,
                        (var_cnt + 1) * sizeof( var ) );
 
        variables[ var_cnt ].varname = strdup( varname );
        variables[ var_cnt ].value = strdup( value );
        var_cnt++;
}
 
char* getvar( char* varname )
{
        int            i;
 
        strupr( varname );
 
        /* Suche Speicherplätze und gebe Wert zurück */
        for( i = 0; i < var_cnt; i++ )
        {
                if( strcmp( variables[i].varname, varname ) == 0 )
                {
                        return variables[i].value;
                } 
        }
 
        return "";
}
 
 
char* getnexttoken( char** line )
{
        char* start;
 
        while( **line == '\t' || **line == ' ' )
                (*line)++;
 
        start = *line;
 
        do
        {
                (*line)++;
        }
        while( **line != ' ' && **line != '\n' );
 
        **line = '\0';
        (*line)++;
 
        return start;
}
 
char* getargument( char* line )
{
        char*         arg;
        static char   str             [ 80 + 1 ];
 
        arg = getnexttoken( &line );
        strupr( arg );
 
        /* Argument ermitteln und verarbeiten */
        if( strcmp( arg, "INPUT" ) == 0 )
        {
                gets( str );
                return str;
        }
        else if( strcmp( arg, "VALUE" ) == 0 )
                return getvar( getnexttoken( &line ) );
        else if( strcmp( arg, "TEXT" ) == 0 )
                return line;
        else
                return ""; 
}
 
int execute( char* line )
{
        char* statement;
        char* var;
        char   value           [ 80 + 1 ];
        int    calcvalue       = 0;
 
        statement = getnexttoken( &line );
        strupr( statement );
 
        /* Anweisungen verarbeiten */
        if( strcmp( statement, "PRINT" ) == 0 )
                printf("%s", getargument( line ) );
        else if( strcmp( statement, "STORE" ) == 0 )
        {
                var = getnexttoken( &line );
                putvar( var , getargument( line ) );
        }
        else if( strcmp( statement, "CLS" ) == 0 )
                system("cls");
        else if( strcmp( statement, "NEWLINE" ) == 0 )
                printf("\n");
        else if( strcmp( statement, "ADD" ) == 0 || strcmp( statement, "SUBSTRACT") == 0 ||
                strcmp( statement, "DIVIDE") == 0 || strcmp( statement, "MULTIPLY") == 0 )
        {
                var = getnexttoken( &line );
 
                if( strcmp( statement, "ADD" ) == 0 )
                        calcvalue = atoi( getvar( var ) ) + atoi( getargument( line ) );
                else if( strcmp( statement, "SUBSTRACT" ) == 0 )
                        calcvalue = atoi( getvar( var ) ) - atoi( getargument( line ) );
                else if( strcmp( statement, "DIVIDE" ) == 0 )
                        calcvalue = atoi( getvar( var ) ) / atoi( getargument( line ) );
                else
                        calcvalue = atoi( getvar( var ) ) * atoi( getargument( line ) );
 
                sprintf(value, "%d", calcvalue );
                putvar( var, value );               
        }
        else
        {
                return -1;
        }
 
        return 0;
}
 
int main( int argc, char** argv )
{
        FILE*  source          = (FILE*)NULL;
        char   line            [ 1024 + 1 ];
 
        if( argc < 2 )
        {
                printf("Verwendung:\t\tLITERAL <dateiname>\n");
                return -1;
        }
 
        source = fopen( argv[1], "rt" );
        if( source != (FILE*) NULL )
        {
                while( fgets( line, 1024, source ) != (char*)NULL )
                {
                        line[ strlen( line ) - 1 ] = '\0';
                        if( execute( line ) < 0 )
                                break;
                }
 
                fclose( source );
        }
        else
        {
                printf("Fehler: Datei nicht gefunden.");
                return -1;
        }
 
        return 0;
}

Ein Taschenrechnerprogramm, das Werte multipliziert, ließe sich für diesen Interpreter so definieren:

cls
print text Geben Sie bitte einen Wert ein: 
store wert1 input
print text Geben Sie bitte einen weiteren Wert ein: 
store wert2 input
multiply wert1 value wert2
print text Das Ergebnis der Berechnung lautet: 
print value wert1
newline

Dieses Programm würde bei der Ausführung mit obigem Interpreter zu folgender Ausgabe führen:

Geben Sie bitte einen Wert ein: 5
Geben Sie bitte einen weiteren Wert ein: 4
Das Ergebnis der Berechnung lautet: 20

Siehe auch

Weblinks


Wikimedia Foundation.

Игры ⚽ Поможем написать реферат

Schlagen Sie auch in anderen Wörterbüchern nach:

  • interpréter — [ ɛ̃tɛrprete ] v. tr. <conjug. : 6> • 1155 ; lat. interpretari 1 ♦ Expliquer, rendre clair (ce qui est obscur dans un texte). ⇒ commenter, expliquer, gloser. Interpréter un document. Interpréter abusivement, tendancieusement un texte. ⇒… …   Encyclopédie Universelle

  • interpreter — Interpreter. v. a. Expliquer quelque chose, en estre l interprete. Interpreter bien. interpreter mal. interpreter fidellement, mot à mot. ceux qui ont interpreté l Escriture sainte, interpreté Aristote, &c. comment interpretez vous ce passage?… …   Dictionnaire de l'Académie française

  • interpreter — in‧ter‧pret‧er [ɪnˈtɜːprtə ǁ ˈtɜːrprtər] noun [countable] 1. someone who translates what someone says from one language into another, especially as their job: • Speaking through an interpreter, the Foreign Minister explained how impressed he… …   Financial and business terms

  • interpreter — et donner à cognoistre, Interpretari. Interpreter à mal, Recte facta detorquere. Interpreter le faict d aucun estre fait par despit de soy, In contumeliam suam vertere quod alius gesserit. Interpreter quelque chose en bonne partie, In optima spe… …   Thresor de la langue françoyse

  • Interpreter — Шаблон Interpreter(также известный как Интерпретатор) – Шаблон проектирования Поведенческий шаблон (Behavioral). Решает часто встречающуюся, подверженную изменениям задачу. Содержание 1 Описание 2 Проблема 3 Решение …   Википедия

  • interpreter — intèrpreter m DEFINICIJA inform. program koji prevodi instrukcije iz višeg programskog jezika u strojni jezik i izvršava ih, instrukciju po instrukciju, opr. kompajler ETIMOLOGIJA engl. interpreter ← lat. interpretari …   Hrvatski jezični portal

  • Interpreter — In*ter pret*er, n. [Cf. OF. entrepreteur, L. interpretator.] One who or that which interprets, explains, or expounds; a translator; especially, a person who translates orally between two parties. [1913 Webster] We think most men s actions to be… …   The Collaborative International Dictionary of English

  • interpreter — index judge Burton s Legal Thesaurus. William C. Burton. 2006 …   Law dictionary

  • interpreter — (n.) one who translates spoken languages; a translator of written texts, late 14c., from O.Fr. interpreteor, from L.L. interpretatorem, agent noun from interpretari (see INTERPRET (Cf. interpret)) …   Etymology dictionary

  • interpreter — ► NOUN ▪ a person who interprets foreign speech orally …   English terms dictionary

  • interpreter — [in tʉr′prə tər] n. [ME interpretour < Anglo Fr < OFr interpreteur < LL(Ec) interpretator] 1. a person who interprets; specif., a person whose work is translating a foreign language orally, as in a conversation between people speaking… …   English World dictionary

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”