Beuth Hochschule Einführende Gentle-Programme WS12/13, S. 1 Einführende Gentle-Programme Dieses Papier soll die Syntax und Semantik (die Schreibweise und Bedeutung) von einfachen Gentle Programmen anhand von Beispielen erläutern. Beispiel-01: Das Hallo-Welt-Programm in Gentle 1 root 2 "Hallo Welt!\n" Das root-prädikat eines Gentle-Programms ist nah verwandt mit der main-funktion eines C/C++-Programms und der main-methode eines Java- oder C#-Programms. Beispiel-02: Ein Parser für die GreetingLanguage (Datei prog1a.g) 1 phrase Greeting 2 rule Greeting: "Good" TimeOfDay "!" 3 rule Greeting: "Hello" Name "!" 4 5 phrase TimeOfDay 6 rule TimeOfDay: "morning" 7 rule TimeOfDay: "evening" 8 rule TimeOfDay: "night" 9 10 token Name 11 <<<[A-Z][a-z]+>>> 12 13 root 14 Greeting 15 "No parse error found!\n" Die phrase-prädikate (Greeting und TimeOfDay) entsprechen den Zwischensymbolen einer Grammatik G und Greeting ist das Startsymbol von G. Die string-literale "Good", "!", "Hello" etc. entsprechen Endsymbolen von G. Das Token-Prädikat Name ist ebenfalls ein Endsymbol von G. Es repräsentiert eine beliebige Zeichenkette, die aus einem Großbuchstaben gefolgt von einem oder mehreren Kleinbuchstaben besteht, z.b. John oder Xy. Im root-prädikat wird das phrase-prädikat Greeting aufgerufen. Dieser Aufruf befiehlt dem Ausführer etwa Folgendes: "Versuche, einen aus der Grammatik G ableitbaren Satz einzulesen. Beende das Programm sofort, wenn du in der Eingabe einen syntaktischen Fehler entdeckst". Die Meldung "No parse error found\n" wird also nur dann ausgegeben, wenn der Ausführer in der Eingabe keine syntaktischen Fehler entdeckt. Mit dem Programm prog1a.g kann man somit prüfen, ob ein bestimmter Satz zur GreetingLanguage gehört (wie z.b. "Good night!" und "Hello Xy!") oder nicht (wie z.b. "Good Morning" und "Hello Karl-Heinz!"). Regel-01: Ein string-literal (z.b. "ABC") in einem phrase-prädikat beschreibt eine erwartete Eingabe (ein Lexem in einem Quellprogramm). Ein string-literal in einem anderen Prädikat (z.b. im root-prädikat) wird ausgegeben.
S. 2, WS12/13 Einführende Gentle-Programme Beuth-Hochschule Beispiel-03: Ein Parser, der konkrete Syntax in abstrakte Syntax übersetzt (Datei prog1b.g) 1 type Greeting_AS 2 grt(part1:string, Part2:string) 3 4 phrase Greeting_CS(-> Greeting_AS) 5 rule Greeting_CS(-> grt("go", S)): "Good" TimeOfDay_CS(-> S) "!" 6 rule Greeting_CS(-> grt("he", S)): "Hello" Name_CS(-> S) "!" 7 8 phrase TimeOfDay_CS(-> string) 9 rule TimeOfDay_CS(-> "mo"): "morning" 10 rule TimeOfDay_CS(-> "ev"): "evening" 11 rule TimeOfDay_CS(-> "ni"): "night" 12 13 token Name_CS(-> string) 14 <<<[A-Z][a-z]+>>> 15 16 root 17 Greeting_CS(-> G) 18 print G Dieses Beispiel enthält eine Kopie des vorigen Beispiels. An die Namen der Prädikate Greeting, TimeOfDay und Name wurde hier allerdings jeweils ein _CS angehängt um zu betonen, dass sie zusammen die konkrete Syntax (Conrete Syntax) der Quellsprache beschreiben. Außerdem wurden die umbenannten Prädikate mit je einem out-parameter (rechts vom Pfeil ->) versehen. Diese Parameter bewirken zusammen Folgendes: Während der Ausführer versucht, einen Satz (formuliert in der konkreten Syntax der GreetingLanguage) stückchenweise einzulesen, wird aus diesem Satz stückchenweise eine entsprechende Darstellung in abstrakter Syntax (ein Wert des Typs Greeting_AS) erzeugt. Zum Typ Greeting_AS gehören alle Werte der Form grt(s1, S2), wobei S1 und S2 für beliebige string-werte stehen. Die folgende Tabelle zeigt Beispiele dafür, welche konkrete Syntax (welcher Satz der GreetingLanguage) welcher abstrakten Syntax (welchem Wert des Typs Greeting_AS) entspricht: Sätze der GreetingLanguage (konkrete Syntax) Good morning! Good evening! Good night! Hello John! Hello Xy! Werte des Typs Greeting_AS (abstrakte Syntax) grt("go", "mo") grt("go", "ev") grt("go", "ni") grt("he", "John") grt("he", "Xy") Regel-02: Ein token-prädikat hat automatisch (0 in-parameter und) genau einen out-parameter vom Typ string und liefert die im Quellprogramm gefundene Zeichenkette (das Lexem) als Wert. Regel-03: Ein phrase-prädikat darf höchstens mit (0 in-parametern und) einem out-parameter vereinbart werden. Dieser out-parameter darf aber zu einem beliebigen Typ gehören. In obigem Programm ist der out-parameter des phrase-prädikats TimeOfDay_CS vom Typ string, und der von Greeting_CS ist vom Typ Greeting_AS. Mit dem Gentle-Befehl print kann man Werte aller Typen ausgeben. Der print-befehl ist aber nur für Testausgaben gedacht (und sein Parameter darf/muss nicht in Klammern eingefasst werden). Anmerkung: Die meisten Werte des Typs Greeting_CS werden im obigen Programm nie benutzt, z.b. die Werte grt("pickelhering", "Fensterglas") und grt("", "") etc.
Beuth Hochschule Einführende Gentle-Programme WS12/13, S. 3 Beispiel-04: Ein Compiler, der die englischen Sätze der GreetingLanguage ins Spanische übersetzt (Datei prog1c): 1... 2 Alles wie im vorigen Beispiel (mit Ausnahme des root-prädikats) 3... 4 5 proc outes(greeting_as) 6 rule outes(grt("go", "mo")): "Buenas dias!\n" 7 rule outes(grt("go", "ev")): "Buenas noches!\n" 8 rule outes(grt("go", "ni")): "Buenas noches!\n" 9 rule outes(grt("he", NAME)): "Hola " $NAME "!\n" 10 11 root 12 Greeting_CS(-> G) 13 outes(g) Schon für das vorige Beispiel galt: Die phrase- und token-prädikate lesen einen Satz in der konkreten Syntax der GreetingLanguage ein und erzeugen dabei einen entsprechenden Wert der abstrakten Syntax (einen Wert des Typs Greeting_AS). Das neue proc-prädikat outes übersetzt einen Wert der abstrakten Syntax ins Spanische und gibt das Ergebnis (z.b. "Buenas noches!" oder "Hola Xy!") aus. Jede der ersten drei Regeln übersetzt nur einen bestimmten Wert. Die vierte und letzte Regel übersetzt viele Werte (z.b. grt("he", "John"), grt("he", "Xy"),... etc.) Der Befehl $NAME (in Zeile 9) bewirkt, dass der Wert der string-variablen NAME ausgegeben wird. Den $-Befehl darf man nur auf Ausdrücke der Typen int und string anwenden. Regel-04: proc-prädikate dürfen mit beliebig vielen in-parametern und beliebieg vielen out-parametern vereinbart werden. Regel-05: proc-prädikate sollten so programmiert werden, dass jeder Aufruf (egal mit welchen Parametern) gelingt. Sollte ein Aufruf nicht gelingen, dann gilt das als schwerwiegender Fehler des Gentle- Programmierers und die betreffende Programmausführung wird sofort abgebrochen. Hinweis: Aufrufe von condition-prädikaten dürfen dagegen gelingen oder misslingen. Regel-06: Bei allen Prädikaten mit out-parametern muss vor den out-parametern ein Pfeil -> notiert werden. Im Beispiel-04 hat das Prädikat outes einen in-parameter und 0 out-parameter. Der in-parameter ist vom Typ Greeting_AS.
S. 4, WS12/13 Einführende Gentle-Programme Beuth-Hochschule Die obige Vereinbarung des Prädikats outes besteht aus 4 Regeln, die viele Zeichen gemeinsam haben (z.b. fangen alle mit rule outes(grt( an). Die Wirkung dieser 4 Regeln kann man auch mit einer einzigen Regel und ein paar Alternativen-Anweisungen (alternatives statements) erreichen, wie das folgende Beispiel zeigt: Beispiel-05: Eine andere Formulierung des Prädikats outes: 1 proc outes(greeting_as) 2 rule outes(grt(p1, P2)): 3 { 4 Equal(P1, "go") // Wenn P1 = "go" ist, dann 5 "Buenas " // "Buenas ". Und dann: 6 { // 7 Equal(P2, "mo") "dias!\n" // Wenn P2 = "mo" dann "dias\n" 8 // sonst 9 Equal(P2, "ev") "noches!\n" // Wenn P2 = "ev" dann "noches\n" 10 // sonst 11 Equal(P2, "ni") "noches!\n" // Wenn P2 = "ev" dann "noches\n" 12 } // 13 // sonst 14 "Hola " $P2 "!\n" // "Hola " und P2 etc. 15 } In Zeile 3 bis 15 (grau, hell- und dunkel) steht eine Alternativen-Anweisung mit 2 Alternativen, die durch den sonst-strich in Zeile 13 voneinander getrennt werden. In Zeile 6 bis 12 (dunkelgrau) steht eine Alternativen-Anweisung mit 3 Alternativen (die durch zwei sonst-striche in Zeile 8 und 10 voneinander getrennt werden). Equal ist ein in Gentle vordefiniertes Prädikat. Wenn der Aufruf Equal(P1, "go") in Zeile 4 gelingt, werden die Zeilen 5 bis 12 ausgeführt, sonst wird die Zeile 14 ausgeführt. In den Zeilen 7, 9 und 11 stehen ähnliche Equal-Aufrufe, jeweils mit einem string-literal (d.h. einem Ausgabebefehl) dahinter. Aufgabe-01: Schreiben Sie ein proc-prädikat namens outde, welches einen Greeting_AS-Wert ins Deutsche übersetzt. Definieren Sie das Prädikat mit 4 Regeln (entsprechend dem Prädikat outes im Beispiel-04). Aufgabe-02: Schreiben Sie ein proc-prädikat namens outde, welches einen Greeting_AS-Wert ins Deutsche übersetzt. Definieren Sie das Prädikat mit einer einzigen Regel und Alternativen-Anweisungen (ensprechend dem Prädikat outes im Beispiel-05). Aufgabe-03: Sei einmal angenommen, dass das token-prädikat NAME (aus irgendwelchen Gründen) nur string-werte bis zu einer Länge von 10 Zeichen liefert. Ungefähr wie viele verschiedene Werte des Typs Greeting_AS werden dann vom Prädikat Greeting_CS (als abstrakte Syntax für einen entsprechenden Eingabe-Satz) benutzt? Ihre Lösung braucht nicht genau zu sein, sollte aber weniger als 10 % von der tatsächlichen Anzahl abweichen.
Beuth Hochschule Einführende Gentle-Programme WS12/13, S. 5 Lösung-01: Schreiben Sie ein proc-prädikat namens outde, welches einen Greeting_AS-Wert ins Deutsche übersetzt. Definieren Sie das Prädikat mit 4 Regeln (ensprechend dem Prädikat outes im Beispiel-04). 1 proc outde(greeting_as) 2 rule outde(grt("go", "mo")): "Guten Morgen!\n" 3 rule outde(grt("go", "ev")): "Guten Abend!\n" 4 rule outde(grt("go", "ni")): "Gute Nacht!\n" 5 rule outde(grt("he", NAME)): "Hallo " $NAME "!\n" Lösung-02: Schreiben Sie ein proc-prädikat namens outde, welches einen Greeting_AS-Wert ins Deutsche übersetzt. Definieren Sie das Prädikat mit einer einzigen Regel und Alternativen-Anweisungen (ensprechend dem Prädikat outes im Beispiel-05). 1 proc outde(greeting_as) 2 rule outde(grt(p1, P2)): 3 { 4 Equal(P1, "go") 5 "Guten " 6 { 7 Equal(P2, "mo") "Morgen!\n" 8 9 Equal(P2, "ev") "Abend!\n" 10 11 Equal(P2, "ni") "Nacht!\n" 12 } 13 14 "Hallo " $P2 "!\n" 15 } Lösung-03: Sei einmal angenommen, dass das token-prädikat NAME (aus irgendwelchen Gründen) nur string-werte bis zu einer Länge von 10 Zeichen liefert. Ungefähr wie viele verschiedene Werte des Typs Greeting_AS werden dann vom Prädikat Greeting_CS (als abstrakte Syntax für einen entsprechenden Eingabe-Satz) benutzt? Ihre Lösung braucht nicht genau zu sein, sollte aber weniger als 10 % von der tatsächlichen Anzahl abweichen. Von den benutzten Werten des Typs Greeting_AS haben 3 die Form grt("go", T), nämlich die Werte grt("go", "mo"), grt("go", "ev") und grt("go", "ni"). Alle anderen benutzten Werte haben die Form grt("he", N), wobei N eine Name ist, der vom token-prädikat NAME geliefert wurde. Wie viele solche Namen gibt es? Da es für jedes Zeichen eines Namens 26 Möglichkeiten gibt (ob es sich dabei um 26 große oder un 26 kleine Buchstaben handelt spielt hier keine Rolle) gibt es genau 26 n Namen der Länge n. Bezeichne ALn die Anzahl der Namen der Länge n. Wir suchen die Anzahl der Namen, die mindestens 2 und höchstens 10 Zeichen lang sind, also die Anzahl AL2 + AL3 +... + AL9 + AL10. Man kann sich klarmachen, dass AL9 weniger als 1/25 von AL10 ist (d.h. weniger als 4 % von AL10), und dass die Summe AL2 + AL3 +... AL9 weniger als 5 % von AL10 ausmacht. Also können wir alle Summanden ausser AL10 vernachlässigen (und die oben erwähnten 3 Werte erst recht). AL10 = 26 10 ist etwa gleich 140.000.000.000.000 oder 140 Billionen. Das ist die ungefähre Anzahl aller Namen mit einer Länge bis zu 10 Zeichen und auch die ungefähre Anzahl der verschiedenen Werte, die G nach einem Aufruf Greeting_CS(-> G) haben kann. Läßt man auch längere Namen zu, z.b. bis zu einer Länge von 100 Zeichen, ist die Anzahl natürlich noch sehr viel, wirklich sehr viel größer.