Zitat von
Christian Seehase:
Moin Malo,
als erstes solltest Du Dir mal darüber Gedanken machen, was für Bestandteile die Sprache haben soll, und wie diese aufgebaut sein sollen.
Ja, darüber hab ich mir auch schon Gedanken gemacht. Wichtiger fand ich es zunächst jedoch, überhaupt einen Denkanstoß zu kriegen, wie man das ganze vom Prinzip her macht. Also, wie ich den Quellcode überhaupt überprüfen kann. Bevor ich da keine Ideen hab, bringt mir auch eine noch so ausgeklügelte Sprachgestaltung nichts
Zitat von
Christian Seehase:
Beispiel:
Bezeichner (für Variablen, Keywords, Datentypen):
Regel : dürfen nur aus Buchstaben und Ziffern bestehen, müssen mit einem Buchstaben anfangen.
Zahlen:
Regel : dürfen nur aus Ziffern bestehen, müssen mit einer Ziffer ungleich 0 beginnen, Wertebereich von / bis.
Strings:
Regel : müssen mit ' beginnen, müssen mit ' enden.
Operatoren:
Regel : erlaubt sind +,-,*,/,=,; (in Deinem Beispiel noch $ als Kennzeichen, dass eine Variable folgt)
Naja, da halte ich mich auch ein wenig an andere Programmiersprachen. Zahlen, die mit 0 beginnen (sofern es sich nicht wirklich um eine 0 haltet) sind ja auch ein wenig witzlos.
Ob man bei Strings nun ' oder " oder was ganz anderes verwendet, ist eher nebensächlich. Das, wo ich mir bisher die wenigsten Gedanken drüber gemacht hab, sind die Operatoren, die ja die wichtigsten sind...
Zitat von
Christian Seehase:
Jeder dieser Bestandteile ist ein Token, dass sich aus Typ und Attribut zusammensetzt.
Bei einem Bezeichner wäre das dann z.B. Typ: Bezeichner, Attribut: EineIntVariable
oder das =: Typ: Operator Zuweisung, Attribut: <Keines erforderlich>
Ist mir auch schon so ziemlich klar, dass ich jedem Token diese Regeln zuweisen muss...
Zitat von
Christian Seehase:
Wenn Du jetzt also Deine Bestandteile und die Regeln, wie sie gebildet werden hast, kannst Du anfangen die Quelldatei "auseianderzunehmen".
Wie speichere ich die denn am besten in meinem Programm? Eine Klasse für jedes Token und seine Regeln?
Zitat von
Christian Seehase:
Hierbei musst Du dann Zeichen für Zeichen durchgehen, und bei jedem entscheiden, wie es weitergehen kann.
Wieder auf Dein Beispiel bezogen:
Du triffst auf ein i (das aus int).
Da es sich um einen Buchstaben handelt, muss es sich um irgendeinen Bezeichner handeln. Jetzt kannst Du also von hier aus, bis zum ersten Trennzeichen durchgehen (hier ein Blank), und hast anschliessend Deinen Bezeichner int.
1. Token: IDENTIFIER:int
Als nächstes triffst Du auf $
2. Token: OperatorVariable:$
jetzt folgt wieder ein Bezeichner usw.
Jetzt wirds spannend... Das kann man ja prinzipiell ganz praktisch in einer Stringliste machen. Dann brauch ich mir keine Gedanken darüber machen, wie ich bis zum nächsten Leerzeichen gehe. Dann könnte ich ein Array nehmen, wo ich dann die Informationen reinschreib (die gleichen Indizen wie bei der Stringliste vorrausgesetzt). Ist der Ansatz soweit korrekt?
Zitat von
Christian Seehase:
Wenn Du auf einen Kommentar triffst, kannst Du diesen natürlich überlesen, denn er hat ja mit dem Ablauf nichts zu tun.
Tja, das ist ja klar
Zitat von
Christian Seehase:
Als Interpreter solltest Du eine ganze Zeile am Stück in Token verwandeln (gekennzeichnet bei Dir durch
, und kannst anschliessend darangehen die Zeile auszuwerten:
1. Token ist ein Datentyp
=> jetzt muss ein $ folgen
=> jetzt muss ein Bezeichner folgen, der kein Keyword ist (hier: OK, kann in die Liste der Variablen als integer-Variable aufgenommen werden)
=> jetzt muss ein logisches Zeilenende folgen
Ja, mit der Stringliste könnte ich dann auch einen Index nach dem anderen durchgehen und abfragen, ob das so korrekt ist, oder nicht...
Zitat von
Christian Seehase:
Jetzt bis zum "physikalischen"-Zeilenende (#13#10) wieder von Vorne, da nur noch ein Kommentar folgt geht's weiter:
Ist diese aufgespalten:
1. Token ein $
=> Jetzt muss eine Variable folgen. In der Liste ist diese, als kann es weitergehen, sonst Fehler
=> Jetzt muss eine Zuweisung folgen.
=> Da es sich um eine integer-Variable handelt, muss jetzt ein numerischer Ausdruck folgen (Variablen, Zahlen, Operatoren)
=> eine 10, also wird der Variablen in der Liste jetzt dieser Wert zugeordnet.
Ich hätte dafür jetzt mal die Idee, dass ich ja prinzipiell ein Array of TStrings erstelle (also ein Array von Stringlisten). In jede StringListe schreib ich dann eine Zeile (Programmzeile, endet beim ; ) rein. Die Kommentare streich ich am besten ganz aus dem auszuwertenden Quelltext (bei einzeiligen Kommentaren ist das dann wohl die einzige Stelle, bei der ich auf "physikalische" Zeilenenden achten muss, glaub ich
Zitat von
Christian Seehase:
....
Das ist jetzt nur einmal grob vereinfacht dargestellt.
Als Suchbegriffe zu diesem Thema kannst Du es mal mit Compilerbau, DEA (Determinierender endlicher Automat), Zustandsautomat versuchen.
Zum Thema
Compilerbau solltest Du sogar hier fündig werden. Letztens hat hier jemand auf ein gutes Online-Buch zum Thema verlinkt gehabt.
Im Moment zur Hand habe ich diesen
Compilerbau Danke, ich werd dann mal suchen. Geld für Bücher will ich nicht unbedingt ausgeben, jedenfalls noch nicht. Solange es nur so eine poplige Scriptsprache ist...
@Airblader: Verkompliziere das bitte nicht unnötig. Ich will dann halt immer Leerzeilen als Begrenzung haben, basta
Gehört meiner Meinung auch zum guten Programmierstil... alles so eng zu schreiben ist eklig
