Diskussion:Interpreter

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Diese Diskussionsseite dient dazu, Verbesserungen am Artikel „Interpreter“ zu besprechen.

Persönliche Betrachtungen zum Thema gehören nicht hierher. Für allgemeine Wissensfragen gibt es die Auskunft.

Füge neue Diskussionsthemen unten an: Klicke auf Abschnitt hinzufügen, um ein neues Diskussionsthema zu beginnen, und unterschreibe deinen Beitrag bitte mit oder --~~~~.

Hinweise

Archiv-Tabelle Archiv
Zum Archiv
Automatische Archivierung
Auf dieser Seite werden Abschnitte automatisch archiviert, die seit 120 Tagen mit dem Baustein {{Erledigt|1=~~~~}} versehen sind.

Der Interpreter in Gestalt der universellen Funktion[Quelltext bearbeiten]

In der Theorie, mit ihren einfachen, aber dafür noch exakt analysierbaren Modellen, findet man den Interpreter in Gestalt der universellen Funktion der Standardnummerierung der berechenbaren Funktionen wieder, wobei gilt. Siehe auch utm-Theorem.
Warum ist diese 2-stellige Funktion ein Interpreter? Nun, ist das Programm (siehe natürliche Zahlen), d.h. ist in der Lage für jedes gegebene Programm, zu jedem Eingabewert den Ausgabewert (der per Semantik zugeordneten berechenbaren Funktion) zu berechnen. kann somit für alle denkbaren Programme, deren Ausgabe bestimmen. Genau das ist ein Interpreter.
Ein Übersetzer macht etwas anderes, der wandelt Programme der Sprache A in Programme der Sprache B, wobei B direkt ausführbar sein kann. (Hier ist dann z.B. die CPU ein in Hardware realisierter Interpreter für B Programme).
--Marc van Woerkom 02:14, 3. Sep 2004 (CEST)

Der erste Satz dieses Artikels ist unverständlich (erl.)[Quelltext bearbeiten]

Der erste Satz dieses Artikels ergibt keinen Sinn und ist irgendwie verunglückt. --84.180.232.38 5. Jul 2005 15:54 (CEST)

Ist jetzt ueberarbeitet. --Hullbr3ach 18:18, 23. Jul 2005 (CEST)

Verschiebung von „Ein einfacher Interpreter“[Quelltext bearbeiten]

Der Absatz "Ein einfacher Interpreter" sollte nach WikiSource verschoben und eine Referenz darauf gesetzt werden. --PhilippW 16:09, 2. Apr 2006 (CEST)

Ja, das finde ich auch. Hier wirkt dieser Abschnitt nämlich etwas deplaziert und den Artikel überladend. Ersatzweise könnte dieser Abschnitt aber auch erstmal in einen eigenen Artikel, eben beispielsweise nach „Ein einfacher Interpreter“, geschoben werden. --92.225.60.52 11:41, 30. Jun. 2012 (MESZ)
Ich denke nicht dass Wikisource der richtige Ort ist für diesen Sourcecode. Sourcecode gibt es dort nämlich nicht, sondern "nur" Literatur. Das Software Wiki ist aber denke ich auch nicht der richtige Platz - dort findet sich Software, aber kein Sourcecode. Wohin also, wenn nicht löschen? --Sebastian.Dietrich 08:57, 4. Sep. 2012 (CEST)

Der Begriff Interpretersprache ist unklar[Quelltext bearbeiten]

Okay, Interpreter habe ich verstanden.
Was ist denn bitte eine Interpretersprache? Für praktisch jede Programmiersprache gibt es Interpreter und Compiler. Z.B. für C gibt es Interpreter. Ist C jetzt eine Interpretersprache? Doch keine Compilersprache? Oder beides?
Der Begriff macht keinen Sinn. Nur Implementationen von Programmiersprachen sind Interpreter- und/oder Compiler-basiert. Die Programmiersprachen sind unabhänging davon, wie sie implementiert sind.
Oftmals werden Programmiersprachen, für die ein Compiler existiert, der Code für eine Virtual Machine erzeugt, Interpretersprache genannt. Auch das ist falsch. Ein typisches Beispiel ist Java.
Oftmals glaubt man auch, Interpretersprachen würden sich dadurch auszeichnen, dass sie interaktiv benutzt werden können. Das ist auch nicht richtig - den gleichen Effekt erzielt man mit inkrementellen Compilern.
Viellecht ist eine Interpretersprache eine Programmiersprache, für die es nur Interpreter-basierte Implementationen gibt? Das kann sich aber leicht ändern, in dem jemand einen Compiler für die Programmiersprache schreibt. Für PHP gibt es Compiler. Für Basic gibt es reichlich Compiler. Python ist auch nicht 'interpretiert'. Für Perl 6 gibt es mindestens einen Compiler.
Viellecht ist eine Interpretersprache eine Programmiersprache, für die es jetzt eine dominierende Interpreter-basierte Implementation gibt?
Ich würde den Begriff einfach streichen.
(Der vorstehende Beitrag stammt von 128.30.29.78 – 19:56, 23. Jul. 2006 (MESZ) – und wurde nachträglich unterschrieben.)

Ich würde den Begriff mit Zusatzerklärung in Anführungszeichen setzten: Es ist schon so, daß Basic von der Entwicklung her eine "Interpretersprache" und C eine "Compilersprache" sind. Es gibt zwar auch C-Interpreter aber wegen möglicherweise stark verschachtelten Präprozessor-Anweisungen würde die Latenzzeit nahezu unendlich sein. (Man -oder auch frau - stelle sich den completten Quellcode eines Linux-Betriebssystems in einem C-Interpreter vor - viel Spass. ;) )
(de.wikipedia.org/wiki/Präprozessor)
--77.20.205.165 16:21, 10. Jul. 2008 (CEST)

JIT-Compiler[Quelltext bearbeiten]

Der Absatz wo der JIT-Compiler erwähnt wird ist falsch. Denn der JIT-Compiler bearbeitet Zwischencode (Bytecode) und nicht Maschinencode. Außerdem ist dieser genauso "Plattformunabhängig" wie der Interpreter.
Quellcode -> Compiler -> Zwischencode
Zwischencode -> JIT-Compiler (virtuelle Machine) -> Maschinencode/Ausgabe
[ZITAT]
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 zur Laufzeit vor seiner Ausführung 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.
[/ZITAT]
--Obstfliege
(Der vorstehende Beitrag stammt von 87.78.40.98 – 19:14, 10. Jan. 2007 (MEZ) – und wurde nachträglich unterschrieben.)

Die Formulierung lautet sogar direkt "Allerdings sind solche Interpreter natürlich nur auf einer bestimmten Rechnerarchitektur lauffähig, weil sie Maschinencode für diese Architektur erzeugen.". Interpreter sind aber _immer_ platformabhängig. --160.45.114.219 15:40, 21. Jan. 2011 (CET)

Weitere Vorteile[Quelltext bearbeiten]

ein anderer Vorteil eines Interpreters ist, dass er dem Benutzer einen Interaktiven Betrieb ermöglicht
(Der vorstehende Beitrag stammt von 130.83.32.211 – 09:59, 11. Jun. 2007 (MESZ) – und wurde nachträglich unterschrieben.)

Stimmt – zum Teil :-) – also nur wenn unter einem interaktiven Betrieb auch das Ändern des gesamten Programmes ferstanden wird. Zudem sollten mal die F(V)orteile noch besser ausgearbeitet werden. Im aktuellen Zustand macht der Artikel auf mich jedenfalls den Eindruck, als ob diese Technik dort mutwillig schlecht gemacht werden soll. Es muß jedenfalls nicht sein, daß an zwei Stellen – zuerst in der Einleitung (Hallo? Was haben dort bitte schon die Vor- und Nachteile zu suchen?) und dann nochmal im Abschnitt „Geschwindigkeitssteigerungen“ – die Nachteile (welche wohl nur Einer sind, also die längere Laufzeit, da hier eben einfach noch die Übersetzungszeit in die Laufzeit einfließt) lang und breit beschrieben werden und der eine (im Moment nur angedoitete) Forteile (also die Abstaktion oder Abhebung/Abtrennung fon der Hartware in Richtung Plattformunabhängigkeit) nur irgendwo im Texthaufen kwasi mal eben so nebei genannt wird. --92.225.60.52 11:55, 30. Jun. 2012 (MESZ)

Ein einfacher Interpreter[Quelltext bearbeiten]

Gehört so ein Code-Beispiel wirklich in die Wikipedia? o.O 194.105.96.202 21:18, 12. Jan. 2009 (CET)

Ich finde es super!!! Das ist, was wikipedia auszeichnet - clevere Ideen, die man garnicht erwartet hätte. Welch eine Kreativität, ich wollte gerade hier ein Dankeschön schreiben - das macht es endlich anschaulich! --ThorstenStaerk 17:41, 9. Dez. 2009 (CET)

Ich habe den Code mal kurz überflogen und wollte schnell per Copy&Paste den Code kompilieren. Was mir aufgefallen ist, strupr() wird bei mir nicht gefunden. Welchen Rückgabewert hat int putvar( char* varname, char* value )? line[1024 + 1] wird mit fgets( line, 1024, source ) gefüllt und anschließend mit line[ strlen( line ) - 1 ] = '\0'; abgeschlossen. Wieso überschreibt man, in dem Fall das 1024 Zeichen gelesen worden sind, das 1024ste Zeichen und nicht das 1025? Irgendwie stellt sich doch die Frage, wer hat den Code getestet...
(nicht signierter Beitrag von 91.8.40.75 (Diskussion) 12:46, 13. Nov. 2010 (CET))

Ja, es wäre in der Tat schön wenn das Programm auch wirklich einfach – fon jedem der Interesse daran hat – nachprüfbar ausführbar wäre. Allerdings müßte dazu auch mal die Umgebung möglichst genau fon den Entwicklern beschrieben oder zumindest mal genannt werden. Also welcher Compiler (sprich Komailer, mit welchem C-Dialekt) wurde für die Erstellung und Übersetzung genutzt? Mittlerweile gibt es ja einen ganzen Zoo, ach was schreib ich.., ganze Inseln oder Kontinente mit auf C (sprich Zeh) aufbauenden oder dafon abgeleiteten Sprachen. Und jeder Übersetzter (Kompilierer-Programmierer) macht da mehr oder weniger sein eigenes Ding. --92.225.60.52 12:27, 30. Jun. 2012 (MESZ)

So ein Code-Beispiel gehört sicher nicht in die Wikipedia. Hier findet man ja auch keine Code-Beispiele zu Flugsimulator oder Textverarbeitung. Siehe dazu auch Diskussion:Compiler#Quelltexte. --Sebastian.Dietrich 10:39, 26. Dez. 2011 (CET)

Ja, das wurde oben schon einmal angemerkt. Nun muß sich nur noch jemand dafür einsetzen, beispielsweise die genannte Verschiebung auszuführen. Es wäre nämlich sehr schade, wenn der Abschnitt einfach nur restlos gelöscht würde. --92.225.60.52 11:37, 30. Jun. 2012 (MESZ)

Ich schiebe ihn einfach mal hierher. So ist er zumindest nicht verloren. --Siehe-auch-Löscher (Diskussion) 11:18, 1. Feb. 2013 (CET)

Codebeispiel schön und gut. Allerdings ist C nur für die Umsetzung geeignet, aber nicht für ein kurzes, verständliches Beispiel. Und auch die interpretierte Sprache sollte nicht irgendwelches spontan aus den Fingern gesaugtes Zeug sein, sondern etwas Bekannteres. Warum also nicht auf den Klassiker ausweichen und einen Interpreter schreiben/kopieren, der Scheme in die Ausgangssprache übersetzt? Oder eben eine Teilmenge davon. Was die Ausgangssprache angeht bin ich spontan für Haskell oder Python, zur Not auch etwas wie C#. Irgendeeine "einfache" Hochsprache, die funktionale Elemente hat. Und schau an, in mindestens den ersten beiden Sprachen haben das schlaue Leute schon mal gemacht. Ich hab nur im Moment nicht die Zeit mich um Urheberrechtsfragen zu kümmern. --82.113.98.210 04:06, 17. Jul. 2013 (CEST)

Codebeispiel[Quelltext bearbeiten]

Folgendes in der Programmiersprache C implementierte Programm stellt einen C89-konformen 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>
#include <ctype.h>
 
typedef struct {
    char* varname;
    char* value;
} variable;
 
variable* variables = NULL;
int       var_cnt = 0;
 
void strtoupper(char* str) {
    while(*str != '\0')  {
        *str = toupper(*str);
        str++;
    }  
}
 
char*  strduplicate(const char* str) {
    char* n = malloc(strlen(str) +1);
    if(n != NULL) 
        strcpy(n, str);
    return n;
}
 
int putvar(char* varname, const char* value) {
    int i;
 
    strtoupper(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 != NULL) {
                free(variables[i].value);
            }
            variables[i].value = strduplicate(value);
            return 0;
        }
    }
    /* Neue Variable anlegen */
    variables = realloc(variables, (var_cnt + 1) * sizeof(*variables));
    if(variables == NULL)
        return 0;
 
    variables[var_cnt].varname = strduplicate(varname);
    variables[var_cnt].value   = strduplicate(value);
    var_cnt++;
    return 1;
}
 
char* getvar(char* varname) {
    int i;
 
    strtoupper(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);
    strtoupper(arg);
 
    /* Argument ermitteln und verarbeiten */
    if(strcmp(arg, "INPUT") == 0) {
        scanf("%80s", str);
        return str;
    }
    else if(strcmp(arg, "VALUE") == 0)
        return getvar(getnexttoken(&line));
    else if(strcmp(arg, "TEXT") == 0)
        return line;
    else
        return NULL;
}
 
int execute(char* line) {
    char*   statement;
    char*   var;
    char*   print;
    char    value[80 + 1];
    int     calcvalue = 0;
 
    statement = getnexttoken(&line);
    strtoupper(statement);
 
    /* Anweisungen verarbeiten */
    if(strcmp(statement, "PRINT") == 0) {
        print = getargument(line);
        if(print == NULL) return -1;
        printf("%s",  print);
    } else if(strcmp(statement, "STORE") == 0) {
        var = getnexttoken(&line);
        putvar(var , getargument(line));
    } else if(strcmp(statement, "CLS") == 0) {
        #ifdef _WIN32
            system("CLS");
        #elif defined __unix__
            system("clear");
        #endif 
    } else if(strcmp(statement, "NEWLINE") == 0) {
        putchar('\n');
    } else if(strcmp(statement, "ADD") == 0 || strcmp(statement, "SUBTRACT") == 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, "SUBTRACT") == 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 = NULL;
    char  line[1024 + 1];
    unsigned int line_nr = 0;
 
    if(argc < 2) {
        printf("Verwendung: %s <dateiname>\n", argv[0]);
        return EXIT_SUCCESS;
    }
 
    source = fopen(argv[1], "rt");
    if(source !=  NULL) {
        while(fgets(line, 1024, source) != NULL) {
            line_nr++;
            if(line[strlen(line) - 1] == '\n')
                line[strlen(line) - 1] = '\0';
            if(execute(line)) {
                fflush(stdout);
                fprintf(stderr, "\nFehler in Zeile %u\n", line_nr);
                break;
            }
        }
        fclose(source);
    }
    else {
        puts("Fehler: Datei nicht gefunden.");
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

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

Aussprache[Quelltext bearbeiten]

Es wäre schön, wenn einer der Autoren die Aussprache von "Interpreter" in IPA-Lautschrift einfügen könnte.-- 93.222.221.190 15:27, 8. Aug. 2009 (CEST)

Welche Aussprache sollte denn dort hin? Dieses Wort wird doch (zumindest in unserer Sprache, also in Deutsch, spich Doitsch) genau so ausgesprochen wie es da steht, was zugegeben anscheinlich allerdings schon fast Seltenheitswert hat, bei der ständigen Überanpassung hier, an die Englische oder andere Fremdsprachen, die je nach Fachgebiet, eben gerade so in Mode sind. --92.225.60.52 11:58, 30. Jun. 2012 (MESZ)

Bekannte Programmiersprachen, die üblicherweise in Bytecode übersetzt werden[Quelltext bearbeiten]

"Bekannte Programmiersprachen, die üblicherweise in Bytecode übersetzt werden, sind Java, C#, Perl und Python."
Ahja. Perl wird aber meines Wissens nach Interpretiert oder zumindest JIT kompiliert. Java und C# sind finde ich dumme Beispiele, diese werden zwar in Bytecode übersetzt, allerdings wird dieser Bytecode später nochmal interpretiert bzw. JIT kompiliert, für die Zielplattform. Wie wärs mal mit den klassikern: C(++), Assembler fallen mir da grade ein die wirklich immer "normal" kompiliert werden --87.180.181.208 01:25, 2. Aug. 2010 (CEST)

Bitte mal nachlesen, was Bytecode und was eine virtuelle Maschine ist. C und Assembler (sic) werden ganz bestimmt nicht in Bytecode übersetzt. Naja, C kann man wohl auch in z.B. JVM-Bytecode übersetzen, und für die JVM gibt es meines Wissens auch einen Assembler.
  • Bytecode: Maschinensprache einer virtuellen Maschine
  • virtuelle Maschine: eine simulierte Maschine, z.B. für bessere Portabilität oder um mehrere VM (völlig isorliert) auf einem Rechner laufen zu lassen (z.B. Java Sandbox oder um mehrere Betriebssysteme gleichzeitig auf einem Rechner auszuführen). Der Simulator (oder Interpreter) läuft natürlich auf realer Hardware.
Schon lustig, C und Assembler sind grad die Antibeispiele :-)
--Vulture 11:15, 28. Sep. 2010 (CEST)

Nachteile des Interpreter als erstes Statement[Quelltext bearbeiten]

Ich finde es einfach ungünstig, etwas zu beschreiben und gleich auf seine Nachteil hinzuweisen. Das ist respektlos, egal worum es geht.
Der Interpreter hat seine Vorteile und die würde ich erstmal ganz oben hin setzen. Das läßt sich zusammen mit den Eigenschaften gut beschreiben.
Dann ist generell der Hinweis, Interpreter wären langsam, schon uralt. Den kenne ich schon seit 20 Jahren. Stimmt das denn angesichts von Quad-Core Prozessoren überhaupt noch? Wenn ich mit Smalltalk arbeite, kann ich keine Performance-Unterschiede zu C# mehr feststellen. Die Datenbank mit den Plattenzugriffen ist der Flaschenhals. Der Prozessor langweilt sich eher die ganze Zeit, egal ob ich Smalltalk, Basic oder C# programmiere. Diese Aussage müßte also unbedingt erneut geprüft werden!! Wir sitzen doch alle nicht mehr vor einem 8086.
(nicht signierter Beitrag von 129.187.107.99 (Diskussion) 15:45, 3. Feb. 2011 (CET))