Diskussion:Interpreter/Archiv
Verschiebung von „Ein einfacher Interpreter“
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
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
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
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
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
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
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
"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)