definitie taal van een grammatica
DESCRIPTION
Definitie Taal van een grammatica. Zij grammatica G = ( T , N , R, S ) de taal van G is. L(G). { z T * | S * z }. Ambigue grammatica. Een grammatica is ambigu als er een zin is met een niet-unieke ontleding. Unieke ontleding. - PowerPoint PPT PresentationTRANSCRIPT
DefinitieTaal van een grammatica
Zij grammatica G = ( T, N, R, S )
de taal van G
is
{ z T* | S * z }
L(G)
Unieke ontleding
Een zin heeft een unieke ontleding als er maar één ontleedboom isof equivalent: er maar één leftmost derivation is
Ambigue grammatica Een grammatica is ambigu als
er een zin is met een niet-unieke ontleding
Grammatica-transformaties
Aanpassen van de regels, zo dat• De taal hetzelfde blijft• Wenselijke eigenschappen ontstaan
Regels (ont)expanderen Linksrecursie verwijderen Prioriteiten van operatoren inbouwen
Transformaties Operatoren met prioriteiten
Heeftdezelfd
e taal als
E E + E
E E * E
E ( E )E N
* gaat nuvoor +
E TE T + ET FT F * TF ( E )F N
Haskell datatypevoor ontleedbomen Grammatica-regels Haskell datatype
dat ontleedboom representeert{ X A B
, X C d , X e }
data X = A B | C d | e
Een
TweeDrie
show :: X Stringshow (Een a b) = show a ++ show bshow (Twee c) = show c ++ “d”show (Drie) = “e”
parse :: String X
uit deabstracte syntax
kun jeconcrete syntaxreconstrueren
Grammatica “Expressie” Expr Term Rest Rest + Expr Rest – Expr Rest Term Getal Term ( Expr )
Expr Term ( + Term| – Term) *
Term Getal | ( Expr )
EBNF-notatie
ANTLR-notatie
Expr : Term ( PLUS Term | MINUS Term ) * ;
Term : Getal| LPAREN Expr RPAREN ;
PLUS : ‘+’ ;MINUS : ‘–’ ;LPAREN : ‘(’ ;LPAREN : ‘(’ ;
class ExprParser extends Parser
class ExprLexer extends Parser
ANTLR genereert JavaExpr : Term
( PLUS Term | MINUS Term ) *
;Term : INT
| LPAREN Expr RPAREN ;
public void expr (){ term (); loop1: while (true) { switch(sym) { case PLUS: match(PLUS); term (); break; case MINUS: match(MINUS); term (); break; default: break loop1; } }}public void term(){ switch(sym) { case INT: match(INT); break; case LPAREN: match(LPAREN); expr (); match(RPAREN); break; default: throw new ParseError(); }}
ANTLR-notatie
Expr
: Term ( PLUS Term| MINUS Term) *
;Term: GETAL| LPAREN Expr RPAREN ;
returns [int x=0]{ int y; }
returns [int x=0]
x= y
=y=
x=
{ x += y; }{ x –= y; }
n: { x = str2int(n.getText(); }
ANTLR-ArchitectuurExpr . g
ExprMain. java
ExprLexer. java
ExprParser. java
ANTLR
* . class
Java compiler
Antlr . jar
Java interpreter zin
Haskell Parser Combinator Architectuur
Expr . hsParseLib . hs
Haskell interpreter zin
ANTLR vs. ParserCombinators
Grammatica schrijven in apart taaltje
Genereert Java-code Groot, ingewikkeld
Geen linksrecursie Geen ambiguiteit 1-symbool lookahead
Java
Grammatica schrijven met Haskell-operatoren
Is gewone Haskell-library
Kort
Geen linksrecursie Wel ambiguiteit Onbeperkt lookahead
Haskell
Type van parsers parse :: String X
type Parser = String X
type Parser b = String b
polymorfresultaattype
type Parser b = String (b, String) restant-string
type Parser a b = [a] (b, [a]) polymorfalfabet
type Parser a b = [a] [ (b, [a]) ] lijst resultateni.v.m. ambiguïteit
Simpele parsers X a
symbola :: Parser Char Char
type Parser a b = [a] [ (b, [a]) ]
symbola [ ] =symbola (x:xs)| x==’a’
=| otherwise =
[ (’a’, xs) ][ ]
[ ]
Simpele parsergeneratoren X a
symbol :: Parser a a
symbol a [ ] = [ ]symbol a (x:xs)
| x==a = [ (a,xs) ]
| otherwise = [ ]
symbola :: Parser Char Charsymbola [ ] = [ ]symbola (x:xs) | x==’a’ = [ (’a’,xs) ]
| otherwise = [ ]
a Eq a
te herkennensymbool is nu
parameter
Andere parsergeneratoren
token :: Eq a [a] Parser a [a]
satisfy :: (aBool) Parser a a
token t xs
where n = length t
| t == take n xs=
| otherwise =
[(t, drop n xs)][ ]
satisfy p [ ] =satisfy p (x:xs)
| p x =| otherwise =
[ ]
[(x, xs)][ ]
Publieksvraag
satisfy :: (aBool) Parser a asatisfy p [] = [ ]satisfy p (x:xs) | p x = [ (x,xs) ]
| otherwise = [ ]
symbol :: Eq a a Parser a asymbol a [] = [ ]symbol a (x:xs) | x==a = [ (a,xs) ]
| otherwise = [ ]
Als satisfy al bestaat,kun je symbol ookmaken. Hoe?
symbol a = satisfy (==a)
Triviale parsers X
epsilon :: Parser a ()epsilon xs = [ ( (), xs ) ]
succeed :: b Parser a b
succeed r xs = [ ( r, xs ) ]
failp :: Parser a b
failp xs = [ ]
Publieksvraag X
epsilon :: Parser a ()epsilon xs = [ ( (), xs ) ]
succeed :: b Parser a b
succeed r xs = [ ( r, xs ) ]
Als succeed al bestaat,kun je epsilon ookmaken. Hoe?
epsilon = succeed ()
Gebruik van parsergeneratoren
Maar wat moet je daar nou mee?
… symbol ’a’… token “public” …
… satisfy isDigit …… succeed 1 …
> satisfy isDigit “1ab”[ (‘1’, “ab”) ]
Parser combinatoren X Y | Z
of :: Parser a b Parser a b Parser a b
of p q xs = p xs
q xs
++ voegt succes-lijsten samen
Leuker: notatie als operator
infixr 4 <|>(<|>) :: Parser a b Parser a b Parser a b
(p <|> q) xs =
p xs ++ q xs
Parser combinatoren X Y Z
infixl 6 <*>(<*>) :: Parser a b Parser a c Parser a (b,c)
(p <*> q) xs =p xsq ys
(b,ys) [|,]
(c,zs)
( , )(b,c)
zs
Dit is nog niet de definitieve versie
Hoe deresultaten
combineren?
infixl 6 <*>(<*>) :: Parser a b Parser a c Parser a (b,c)
Parser combinatoren X Y Z
infixl 6 <*>(<*>) :: Parser a b Parser a c
(bcd) Parser a d
( , )(p <*> q) xs = p xs
q ys(b,ys)
[|,]
(c,zs)
(b,c) zs
Dit is nog steeds niet de definitieve versie
f f b c
infixl 6 <*>(<*>) :: Parser a b Parser a c
(bcd) Parser a d
Parser combinatoren X Y Z
infixl 6 <*>(<*>) :: Parser a (cd) Parser a c
Parser a d
( , )(p <*> q) xs = p xs
q ys(b,ys)
[|,]
(c,zs)
(b,c) zsf
f c
Parser nabewerking
infixl 7 <$>(<$>) :: (bc) Parser a b Parser a c
(f <$> p) xs = p xs(b,ys)
[|]
( f b , ys )
Gebruik parsercombinators:controleer geneste haakjes Grammatica Abstracte syntax
{ H , H ( H ) H}
data H =Leeg | Paar H H
haakjes :: Parser Char H
Parser
haakjes = <|>
epsilon
open <*> haakjes <*> sluit <*> haakjes where open = symbol ’(’sluit = symbol ’)’
(\x Leeg) <$>(\a b c d Paar b d) <$>
Publieksvraag
Maak een parser voor booleans
waarheid :: Parser Char Bool
Hint: gebruik token, en bewerk na
waarheid = token “true” <|> token “false”
(\x True) <$>(\x False) <$>
Eigenschappen van de ontleedboom bepalen
Abstracte syntax
data H =Leeg | Paar H H
Grammatica
{ H , H ( H ) H}
aantal :: H Int
Eigenschappendiepte :: H Int aantal Leeg =
aantal (Paar x y)= 0
1 + aantal x + aantal y
diepte Leeg =diepte (Paar x y)=
0
max (1+ diepte x)
(diepte y)
aantalP :: Parser Char Int aantalP = <|>
open <*> aantalP <*> sluit <*>aantalP
epsilon
Eigenschappen al bepalentijdens het ontleden
haakjes :: Parser Char H haakjes = <|>
epsilon
open <*> haakjes <*> sluit <*>haakjes
(\x Leeg) <$>(\a b c d Paar b d) <$>
Parser
(\x 0) <$>(\a b c d 1+b+d) <$>
Parser die aantal meteen uitrekent
Eigenschappen al bepalentijdens het ontleden
haakjes :: Parser Char H haakjes = <|>
epsilon
open <*> haakjes <*> sluit <*>haakjes
(\x Leeg) <$>(\a b c d Paar b d) <$>
Parser
diepteP :: Parser Char Int diepteP = <|>
epsilon
open <*> diepteP <*> sluit <*> diepteP
(\x 0) <$>(\a b c d max (1+b) d) <$>
Parser die diepte meteen uitrekent
Samenwerking van <$> en <*>
(<$>) :: (bc) Parser a b Parser a c(<*>) :: Parser a (cd) Parser a c Parser a d
open, sluit :: Parser Char Charopen = symbol ‘(’sluit = symbol ‘)’test = open <*> sluit(\x y [x,y])
<$> Wat is het type van test ? Hoe associeert f <$> p <*> q
eigenlijk,wil dit überhaupt kunnen?
Samenvatting hst. 3 sec. 1-3
Type van parsers
Elementaire parsers
Parser-combinators
type Parser a b = [a] [ (b, [a]) ] lijst resultateni.v.m. ambiguïteit
satisfy :: (aBool) Parser a asucceed :: b Parser a bfailp :: Parser a b
(<|>) :: Parser a b Parser a b Parser a b(<*>) :: Parser a (bc) Parser a b Parser a c(<$>) :: (bc) Parser a b Parser a c
Werkcollege
Hoofdstuk 3: geselecteerde opgaven Download ParseLib.hs en run met
hugs Definieer ontleedboomtype en
maak parse-functie voor Java If-statement
Vindt-ie de ambiguïteit?{ Expr … , Stat Var = Expr , Stat while ( Expr ) Stat, Stat if ( Expr ) Stat Rest, Rest | else Stat}
Practicum
Schrijf een ANTLR-grammaticavoor Haskell- data types
Lever String als resultaat op, met daarinHaskell-programma voor eenfold -functie voor dat datatype
Inleveren: vrijdag 30 november 2007