Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen

Transkript

1 Praktikum Funktionale Programmierung Teil 1: Lexen und Parsen Professur für Künstliche Intelligenz und Softwaretechnologie Sommersemester 2009

2 Überblick Teil 1: Lexen und Parsen Die Sprache LFP +C Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

3 Die Sprache LFP +C Überblick Die Sprache LFP +C Ausdrücke Expr ::=Var Int True False [] (Expr 1 :Expr 2 ) (Expr 1,Expr 2 ) (\Var -> Expr ) (Expr 1 Expr 2 ) (case Expr of {Alt 1... Alt n }) (letrec Var 1 = Expr 1,..., Var n = Expr n in Expr n+1 ) (seq Expr 1 Expr 2 ) (amb Expr 1 Expr 2 ) (por Expr 1 Expr 2 ) (Expr 1 + Expr 2 ) (Expr 1 - Expr 2 ) (Expr 1 * Expr 2 ) (null? Expr ) case-alternativen und Pattern Alt ::=Pat -> Expr Pat ::=True False [] (Var 1 :Var 2 ) (Var 1,Var 2 ) Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

4 Überblick Ziel Überführe Quelltext in Tokenstrom Token = Eine syntaktische Einheit Dabei: Fasse syntaktische Einheiten wie Zahlen, Variablennamen, Schlüsselworter zusammen Entferne Whitespaces, \n, \r, \t Generiere Fehlermeldung bei unbekannter Syntax Es trat ein Fehler auf. hilft nicht. Besser: Warum und wo tritt der Fehler auf? Deshalb: Beim Lexen die Zeilen und Spalten-Information für die Token mitführen. Fehlermeldung gibt das unbekannte Zeichen aus Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

5 Überblick Der Datentyp LFPCTok > type CodeMark = (Int,Int) -- (Row, Column) > data LFPCTok = TokInt CodeMark Integer -- Ganzzahl > TokVar CodeMark Var -- Variable > TokTrue CodeMark -- True > TokFalse CodeMark -- False > TokNil CodeMark -- [] > TokCons CodeMark -- : > TokPlus CodeMark -- + > TokMinus CodeMark -- - > TokMult CodeMark -- * > TokIsNull CodeMark -- null? > TokLet CodeMark -- letrec > TokIn CodeMark -- in > TokCase CodeMark -- case > TokOf CodeMark -- of > TokComma CodeMark --, > TokCBOpen CodeMark -- { > TokCBClose CodeMark -- } > TokArrow CodeMark -- -> > TokLam CodeMark -- \ > TokBOpen CodeMark -- ( > TokBClose CodeMark -- ) > TokEq CodeMark -- = > TokSeq CodeMark -- seq > TokAmb CodeMark -- amb > TokPor CodeMark -- por Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

6 Überblick Anmerkungen zum Lexer Minuszeichen könnte als [TokInt (1,1) 20, TokInt (1,4) -10] oder als [TokInt (1,1) 20, TokMinus (1,4), TokInt (1,5) 10] erkannt werden. Konvention: Das Minus wird nur dann als negative Zahl erkannt, wenn direkt nach dem Zeichen eine Ziffer folgt, sonst wird es stets als Operator erkannt. Beachte: ergibt [TokInt (1,1) 20, TokInt (1,4) -10] Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

7 Aufgabe 1 Überblick Implementieren Sie die folgenden Funktionen im Modul LFPC.Parse.Lex getcodemark :: LFPCTok -> CodeMark, die die Positionsmarkierung eines Tokens zurück gibt. printlfpctok :: LFPCTok -> String, die ein Token in den ursprünglichen Quelltext des Tokens konvertiert. lexlfpc :: String -> [LFPCTok], die aus einem LFP +C -Quelltext eine Liste von Token erstellt und dabei Kommentare entfernt und für jedes Token dessen Position im Quelltext (Zeile, Spalte) mit abspeichert. Sollte ein Fehler bei der lexikalischen Analyse auftreten, so generieren Sie mit der error-funktion eine Fehlermeldung, die zumindest die Zeile und Spalte des nicht lexbaren Symbols und das Symbol selbst ausgibt. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

8 Überblick Interne Darstellung Datentyp CoreLFPC data CoreLFPC = V CoreVar -- Variable App CoreLFPC CoreLFPC -- Applikation Lambda CoreVar CoreLFPC -- Abstraktion Let [Bind] CoreLFPC -- Letrec-Ausdruck Cons Int Int [CoreLFPC] -- Konstruktoranw. Case CoreLFPC [Alt] -- Case-Ausdruck Seq CoreLFPC CoreLFPC -- Seq-Ausdruck Amb CoreLFPC CoreLFPC -- Amb-Ausdruck Por CoreLFPC CoreLFPC -- Por-Ausdruck deriving (Eq,Show) data Alt = Alt Int Int [CoreVar] CoreLFPC deriving (Eq,Show) data Bind = CoreVar :=: CoreLFPC deriving (Eq,Show) type CoreVar = (CodeMark,Bool,Var,Var) Besonderheiten Einheitliche Darstellung der Konstruktoren mittels Cons i j argumente: i: Nummer des Konstruktors j: Stelligkeit Darstellung der case-alternativen analog Alt i j patternvars rhs Keine Konstrukte für Zahlen und +, -, *, null? Case-Alternativen für jeden Konstruktor Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

9 Überblick Aufgabe des Parsers Ziel Überführe Tokenstrom ([LFPCTok]) in Syntaxbaum (CoreLFPC) Syntax von CoreLFPC abstrakt Expr ::= Var (Expr 1 Expr 2 ) \Var -> Expr c i,k Expr 1... Expr k letrec Var 1 = Expr 1,... Var n = Expr n in Expr case Expr of { Pat 1 -> Expr 1,..., Pat n -> Expr n } seq Expr 1 Expr 2 amb Expr 1 Expr 2 por Expr 1 Expr 2 Pat ::= c i,k Var 1... Var k Erfordert (Parsen) Testen einiger nicht kontextfreier Eigenschaften Erstellen des CoreLFPC-Ausdrucks Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

10 Überblick Parsergenerator happy Automatisches Geniereren eines Shift-Reduce Parsers anhand einer kontextfreien Grammatik und Assoziativitäten und Präzedenzen Erwartet Tokendatentyp und Ausgabedatentyp Aufruf happy Parserbeschreibung Dateiendung der Parserbeschreibung:.y bzw..ly (für Haskell-Literate-Quellcode) Parser.ly schon zu einem großen Teil vorgegeben. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

11 Syntax im Parser Überblick Anders als vorher um Klammern zu sparen CExpr ::= letrec Binds in CExpr Const ::= Var Int False True [] \Var -> CExpr AExpr AExpr ::= AExpr Expr Binds ::= Bind,Binds Bind Expr Bind ::= Var =CExpr Expr ::= amb Expr Expr Alts ::= Alt,Alts Alt por Expr Expr Alt ::= Pat -> CExpr seq Expr Expr null? Expr Pat ::= True False [] Expr :Expr Var :Var (Var,Var ) (CExpr,CExpr ) case Expr of { Alts } Expr *Expr Außerdem: Präzedenzen und Assoziativitäten Expr +Expr Expr -Expr \Var -> Expr (CExpr ) Const Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

12 Überblick Parserbeschreibung (Auszüge) > %name parse > %tokentype { LFPCTok } Token den Elementen der Grammatik zuordnen > %token > int { TokInt _ $$ } > var { TokVar } > + { TokPlus _ } > - { TokMinus _ } > * { TokMult _ } > False { TokFalse _ } > True { TokTrue _ } > [] { TokNil _ } > : { TokCons _ } > NULL { TokIsNull _ } > Let { TokLet _ } > In { TokIn _ } > Case { TokCase _ } > Of { TokOf _ } >, { TokComma _ } > { { TokCBOpen _ } > } { TokCBClose _ } > ( { TokBOpen _ } > ) { TokBClose _ } > -> { TokArrow _ } > \\ { TokLam _ }... Assoziativit"aten und Pr"azedenzen. Die Pr"azedenzen ergeben sich aus der Reihenfolge, der Direktiven, der am weitesten oben stehende Operator hat niedrigste Pr"azedenz. > %right -> > %right In > %right Of > %left NULL > %left seq > %left amb > %left por > %right : > %left + - > %left * > %nonassoc, > %left NEG > %% Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

13 Überblick Parserbeschreibung (Auszüge) CExpr :: {CoreLFPC} CExpr : Let Binds In CExpr { checkbinds $4 $2 $1 } \\ var -> CExpr { Lambda (mkvar $2) $4 } AExpr { $1 } AExpr : AExpr Expr { App $1 $2 } Expr { $1 } Expr : amb Expr Expr { Amb $2 $3 } por Expr Expr { Por $2 $3 } seq Expr Expr { Seq $2 $3 } NULL Expr { mknull $2} Expr : Expr { cons $1 $3 } ( CExpr, CExpr ) { pair $2 $4 } Case CExpr Of { Alts } { checkalts $2 $1 $5 } Expr * Expr { mkmult $1 $3 } Expr + Expr { mkplus $1 $3 } Expr - Expr { mkmin $1 $3 } ( CExpr ) { $2 } Const { $1 } Binds : Bind { [$1] } Bind, Binds { $1:$3 } Bind : var = CExpr { (mkvar $1) :=: $3 } Alts : Alt { [$1] } Alt, Alts { $1 : $3 } Alt : Pat -> CExpr { $1 $3 } Pat : True { alt_true } False { alt_false } var : var { chkaltcons $2 $1 $3 } [] { alt_nil } ( var, var ) { chkaltpair $3 $2 $4 } ( Pat ) { $2 } Const : var { V (mkvar $1) } int { mkint $1 } False { false } True { true } [] { nil } Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

14 Überblick Notwendige z.t. nicht kontextfreie Tests letrec x 1 = e 1,..., x n = e n in e: Sind die Variablen x i alle verschieden? case-ausdrücke: Sind mehrere Alternativen für den gleichen Konstruktor enthalten? Z.B. falsch: case e of {(x: y) e; (a:y) e } case-alternativen: Sind die Pattern-Variablen verschieden? Z.B. falsch: case e of {(x: x) e;...} Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

15 Übersetzung Überblick Variablen x = CoreVar pos(x) flag origname newname, wobei 1 pos(x) = Position im Quelltext (vom Typ CodeMark). 2 f lag: True, wenn Variable im Quelltext vorkam, False wenn interne Variable 3 origname: Der Name der Variablen im Quelltext 4 newname: der aktuelle Name der Variablen (wg. Umbenennungen) Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

16 Übersetzung Überblick Konstruktoren [] = Cons 1 0 [] True = Cons 3 0 [] False = Cons 4 0 [] e 1 : e 2 = Cons 2 2 [ e 1, e 2 ] (e 1,e 2 ) = Cons 7 2 [ e 1, e 2 ] Zero = Cons 5 0 [] One = Cons 6 0 [] e 1,e 2 = Cons 8 2 [ e 1, e 2 ] Beachte: One, Zero und das spezielle Paar a,b gibt es im Quelltext nicht, wird aber für die Kodierung von Ganzzahlen verwendet. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

17 Übersetzung Überblick Zahlen i = s, b n (i):... :b 1 (i):[] wobei { True, wenn i 0 s = False, sonst { Zero, wenn die j-te Stelle von i in Binärdarstellung 0 ist, b j = One, sonst n die Anzahl der Stellen von i in Binärdarstellung ist. Achtung: Binärdarstellung beginnt mit dem niedrigsten Bit. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

18 Übersetzung Überblick Abstraktion, Applikation, seq, amb por \x -> e = Lambda (pos(x),true,x,x) e e 1 e 2 = App e 1 e 2 seq e 1 e 2 = Seq e 1 e 2 amb e 1 e 2 = Amb e 1 e 2 por e 1 e 2 = Por e 1 e 2 letrec letrec bind 1,..., bind n in e = Let [ bind 1,,..., bind n ] e x = e = (pos(x),true,x,x) :=: e Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

19 Übersetzung Überblick case-ausdrücke case e of {alt 1,... alt n} = Case e (sort [ alt 1,..., alt n,alt n+1,...,alt m]) [] -> e = Alt 1 0 [] e True -> e = Alt 3 0 [] e False -> e = Alt 4 0 [] e Zero -> e = Alt 5 0 [] e One -> e = Alt 6 0 [] e (x:y) -> e = Alt 2 2 [(pos(x),true,x,x),(pos(y),true,y,y)] e (x,y) -> e = Alt 7 2 [(pos(x),true,x,x),(pos(y),true,y,y)] e x,y -> e = Alt 8 2 [(pos(x),true,x,x),(pos(y),true,y,y)] e wobei alt n+1,... alt m Alternativen für Pattern die nicht in den ersten n Vorkommen, wobei die rechte Seite solcher Alternative V ((0,0),False," bot"," bot") ist sort die Alternativen anhand der Konstruktornummern sortiert. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

20 Übersetzung Überblick null?, +, -, * null?e = App ((0,0),False," isnull"," isnull") e e 1 +e 2 = App (App ((0,0),False," plus"," plus" e 1 ) e 2 e 1 -e 2 = e 1 +(-1*e 2 ) e 1 *e 2 = App (App ((0,0),False," mult"," mult") e 1 ) e 2 Code für die Funktionen mkouterlet im Modul LFPC.Parse.InternalOp Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

21 Aufgabe 2 Überblick Aufgabe 2 Implementieren Sie in der Parserdefinition Parser.ly (aus der dann das Modul LFPC.Parse.Parser generiert wird), die in den Aktionen verwendeten Funktionen mkint :: Integer -> CoreLFPC die entsprechend der Übersetzung eine Ganzzahl in die Darstellung innerhalb des Datentyps CoreLFPC konvertiert. checkbinds :: CoreLFPC -> [Bind] -> LFPCTok -> CoreLFPC, die den in-ausdruck, die Bindungen, das Token des letrec-ausdrucks erhält, und prüft, ob alle Bindungsvariablen verschieden sind. Ist dies nicht der Fall, so wird eine Fehlermeldung mithilfe der im übergebenen Token steckenden Informationen generiert. Andernfalls wird der letrec-ausdruck in der Darstellung des Datentyps CoreLFPC zurück gegeben. checkalts :: CoreLFPC -> LFPCTok -> [Alt] -> CoreLFPC, die das erste Argument eines case-ausdrucks, das Token für den case-ausdruck und eine Liste von case-alternativen erhält und einen case-ausdruck im Datentyp CoreLFPC erstellt, wobei geprüft werden muss, ob doppelte case-alternativen enthalten sind. Ist dies der Fall, so wird anhand des Tokens eine Fehlermeldung generiert. Man beachte, das die Grammatik case-ausdrücke ohne Alternativen bereits verbietet, und somit in diesem Fall eine Fehlermeldung generiert wird. fehlende Alternativen entsprechend der Übersetzung hinzufügt werden, die Liste der Alternativen anhand der Konstruktornummern sortiert wird. chkaltpair und chkaltcons, die jeweils die Signatur LFPCTok -> LFPCTok -> LFPCTok -> CoreLFPC -> Alt haben, wobei das erste Token das Token für, oder : eines case-patterns ist, das zweite Argument die erste Patternvariable, das dritte Argument die zweite Patternvariable und das vierte Argument die rechte Seite der Alternativen ist. Beide Funktionen prüfen ob die Patternvariablen verschieden sind (andernfalls wird ein Fehler generiert), und liefern anschließend eine Alternative. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1

22 Aufgabe 3 Überblick Aufgabe 3 Geniereren Sie mittels happy den Parser aus der (vervollständigten) Parserspezifikation Parser.ly und testen Sie anschließend den Parser ausgiebig. Professur KIST, SoSe 2009, 20. April Praktikum Funktionale Programmierung, Teil 1