Interpreter schreiben

[YiB]

Hi Leuts!

Ich bin grad dabei einen Interpreter zu schreiben (eigentlich nur ein Teil eines

größeren Projekts), und ich würd mal gern wissen wie die Leute vom Fach das

tun würden

Er sollte mindestens diese Voraussetzungen erfüllen:

• Befehle sollte man leicht hinzufügen können
  
• Natürlich nicht zu lahm
  
• Variablen, Konstanten, Arrays, Funktionen etc...
  
• If, Case, Schleifen, Booleans
  
• evtl. benutzerdefinierte Typen, Prozeduren etc...
  

Tja mehr fällt mir grad nicht ein...

Ich hab schon angefangen mit dem Proggen, und werd warscheinlich auch

nichts Großartiges mehr an meinem Konzept ändern... Aber für weitere

Projekte kanns ja nicht schaden, und außerdem interessieren mich die

verschiedenen Lösungswege

Ich erwarte jetzt keine komplette ausführliche Lösung oder so, nur grobe

Lösungswege...

MfG, YiB

[Guybrush Threepwood]

Für was den ein Interpreter? Ein bestehnde Sprache oder eine ganz neue?

In was Interpretierst du den Code den? In Assembler oder eine höhere Sprache wie z.B. C.

[waterhouse533-lp]

Hallo YiB,

wenn du das Programm in einem halben Jahr noch benutzen willst, ist es auf jeden Fall sinnvoll sich mit Entwurfsmustern zu beschäftigen.

Ansonsten hat DER MÄCHTIGE PIRAT schon recht, für einen guten Rat sind mehr Informationen notwendig.

[geloescht_JesterDay]

Ich bin grad dabei einen Interpreter zu schreiben (eigentlich nur ein Teil eines

größeren Projekts), und ich würd mal gern wissen wie die Leute vom Fach das

tun würden

Also du willst eher eine Interpretersprache entwickeln und Tips dazu so wier ich das verstehe.

Also ich hab früher mal sowas ähnliches gemacht (Kursarbeit). Eigentlich ist es ganz einfach, du musst dir nur eine Struktur ausdenken, die du dann in deinem Interpreter entprechend umsetzen kannst.

z.B. Variablen definieren:

VAR

i:Integer

Wenn dein Interpreter die Zeile mit VAR interpretiert weiss er, in der nächsten Zeile befindet sich eine Variablen Definition: Text bis zum Doppelpunkt = Variablenname und das dahinter der Variablentyp. Natürlich müssen die gewisse Konventionen (Namen ohne leerzeichen o.ä.) einhalten, die du aber selbst vorgeben kannst (oder je nach deiner Programmiersprache und deinem Programm eben selbst einhalten musst in deinem Interpreter).

So ähnlich kannst du es auch mit anderen Strukturen machen

Bsp. For-Schleife:

FOR

1 TO 5

irgendwas

ENDFOR

Hier merkt der Interpreter bei FOR: hier kommt eine Schleife, der Durchlaufzähler wird in der nächsten Zeile erwartet und der Rest bis ENDFOR soll dann entsprechend wiederholt werden.

Das mit den einzelnen Zeilen sind natürlich nur Beispiele, du kannst das auch in eine Zelie schreiben, musst es aber dann umständlicher rausfiltern. Wichtig ist halt, dass du deinen "Code" gut in deinem eigentlichen Programm ausführen kannst.

Also für die Variablen z.B. einen Rekord (Struct) und davon ein dynamisches Array.

Beispielsweise in Delphicode:

Type

MyTypes = (MyInteger, MyString, MyFloat);


MyVarsRec = Record

  Name: String;

  Typ: MyTypes;

  Value: Variant;

end;

[...]

MyVars: Array of MyVarsRec;

Du kannst das ganze natürlich auch ohne feste Variablentypen machen (ähnlich PHP). Ist alles nur eine gobe Idee.

[waterhouse533-lp]

Hallo YiB,

ich habe den Parser nicht selbst gebastelt, sondern antlr benutzt.

Dadurch habe ich etliche Wochen Arbeit gespart.

Das Tool gefällt mir wirklich sehr gut.

[YiB]

Danke erstmal für eure Antworten!

@Guybrush Threepwood:

Der soll so ähnlich wie QBasic werden, nur für Windows...

@waterhouse533-lp:

Entwurfsmuster sind doch sozusagen beschreibungen, wie die einzelnen Teile des Programms funktionieren oder? Das hab ich schon grob aufgeschrieben...

@JesterDay:

Variablen definieren und so wird alles vom Interpreter übernommen, da die Sprache möglichst auch für Anfänger sehr leicht zu benutzen sein soll.

Für die Variablen dachte ich auch, dass ich ein Record/Structure/Type (und wie auch immer das heißt in den verschiedenen Sprachen ) nehmen werde.

So also ich bin inzwischen ein bischen weiter, und er kann immerhin schon einfache Befehle ausführen

Der Interpreter übersetzt den Source zuerst in Bytecode, der ungefähr so aussieht:

- Id des 1. Befehls

- Anzahl der Parameter

- Länge des 1. Parameters

- 1. Parameter (String)

- Länge des 2. Parameters

...

-Id des 2. Befehls

...

Ich denke Schleifen, If-Abfragen usw- werd ich in Labels umwandeln, die eine eigene ID bekommen.

Ich hab alle Funktionen die der Interpreter versteht auch in meinem Programm, und die Poiter dahin in einem Array.

Jetzt hat ja jeder Befehl eine ID, und die steht in dem Array im Index.

Der Interpreter ließt also die ID ein, dann die Parameter und führt dann die entsprechende Funktion durch den Pointer im Array aus. Die Parameter übergibt er in einem String-Array.

Soweit funktionierts auch zuverlässig und relativ schnell

Jetzt hab ich mir erstmal gedanken gemacht wie ich die Konstanten machen soll, und da der Code evtl. vor jeder Ausführung neu "kompiliert" werden muss darf das ersetzen der Konstanten durch ihre Werte auch bei 1000 Konstanten nicht viel länger als eine Sekunde dauern. Ich hab schon in einem anderen Forum gefragt wie ich das anstellen soll, und bin so an Hashtabellen gekommen.

Gibt es vielleicht auch eine noch schnellere Variante?

[mKipke]

Danke erstmal für eure Antworten!

...

@waterhouse533-lp:

Entwurfsmuster sind doch sozusagen beschreibungen, wie die einzelnen Teile des Programms funktionieren oder? Das hab ich schon grob aufgeschrieben...

...

Entwurfsmuster (auch Designpatterns genannt) sind vorgegebene "Methoden", wie ein bestimmtes Verhalten realisiert wird:

Bsp: Singleton

Gewünschtes Verhalten:

Von einer Klasse darf nur eine Instanz erzeugt werden, auf die dann von anderen Komponenten zugegriffen wird:

Realisierung:

Bsp als JAVA-Source

class MyClass {



private static MyClass myClass = null;

//TODO: weitere Attribute


private MyClass() {

//Konstruktor

}


public static myClass getInstance() {

    if (myClass == null) { 

         myClass = new MyClass();

    }

    return myClass;

}


//TODO: weitere Methoden

}

Dieses Muster ist standartisiert - wenn du mit einem anderen Entwickler über einen Singleton redest, weiss dieser, was gemeint ist und wie du das realisiert hast.