Taal nEen Alfabet is… een eindige verzameling symbolen nEen Taal is… een deelverzameling van T* bij een bepaald alfabet T nEen Zin is… een element van een taal nEen Zin van een taal is… een element van die taal

Definitie: (§2.1) Samenstellen van talen L  M L M L0L0 L n+1 L*L* L+L+ L { s t | s  L, t  M } {  } L L n L 0  L 1  L 2  L 3  …… L 1  L 2  L 3  …… T* – L Zoals in de verzamelingenleer

Definitie (§2.3) Taal van een grammatica nZij grammatica G = ( T, N, R, S ) nde taal van G { z  T* | S  * z } L(G)

Definitie (§2.3) Taal van een nonterminal nZij grammatica G = ( T, N, R, S ) nde taal van G nDe taal van een bepaalde A  N { z  T* | S  * z } L(G) { z  T* | A  * z } L(A)

Definitie (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) G 2 = ( T, N 2, R 2, S 2 ) N 1  N 2 =  nAls G = ( T,N 1  N 2  {S},R 1  R 2  { S  S 1, S  S 2 }, S ) nDan is L(G) L(G 1 )  L(G 2 ) Stelling

Stelling (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) G 2 = ( T, N 2, R 2, S 2 ) N 1  N 2 =  nAls G = ( T,N 1  N 2  {S},R 1  R 2  { S  S 1, S  S 2 }, S ) nDan is L(G) L(G 1 )  L(G 2 )

Stelling (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) G 2 = ( T, N 2, R 2, S 2 ) N 1  N 2 =  nAls G = ( T,N 1  N 2  {S},R 1  R 2  ……, S ) nDan is L(G)L(G 1 ) L(G 2 ) { S  S 1 S 2 }

Stelling (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) nAls G = ( T,N 1  {S},R 1  ……, S ) nDan is L(G)L(G 1 ) * { S  , S  S 1 S }

Stelling (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) nAls G = ( T,N 1  {S},R 1  ……, S ) nDan is L(G)L(G 1 ) + { S  S 1, S  S 1 S }

Definitie (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) nAls G = ( T,N 1  {S},R 1  ……, S ) nDan is L(G)L(G 1 ) ? { S  , S  S 1 }

Probleem (§2.7) Samengestelde grammatica nZij G 1 = ( T, N 1, R 1, S 1 ) G 2 = ( T, N 2, R 2, S 2 ) N 1  N 2 =  nAls G = ( T,N 1  N 2  {S},R 1  R 2  ……, S ) nDan is L(G) L(G 1 )  L(G 2 ) ??? Onoplosbaar probleem (§9.3)

Afkorting-notatie nLangn Kort P   P  a P  b P  aPa P  bPb P   a  b  aPa  bPb BNF Backus-Naur Form

Afkorting-notatie nLangn Kort A   A  X A A  X* EBNF Extended Backus-Naur Form B  X + B  X B  X B C  X ? C   C  X

ANTLR-notatie Expr:Term ( PLUS Term | MINUS Term ) * ; Term :Getal | LPAREN Expr RPAREN ; PLUS : ‘+’ ; MINUS : ‘–’ ; LPAREN : ‘(’ ; RPAREN : ‘)’ ; class ExprParser extends Parser class ExprLexer extends Parser

ANTLR genereert Java Expr: 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=x= y=y= y=y= x=x= { x += y; } { x –= y; } n:n: { x = str2int(n.getText(); }

ANTLR-Architectuur Expr. 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 nGrammatica schrijven in apart taaltje nGenereert Java-code nGroot, ingewikkeld nGeen linksrecursie nGeen ambiguiteit n1-symbool lookahead nJava n Grammatica schrijven met Haskell-operatoren n Is gewone Haskell-library n Kort n Geen linksrecursie n Wel ambiguiteit n Onbeperkt lookahead n Haskell

Samenvatting hst. 3 sec. 1-3 nType van parsers nElementaire parsers nParser-combinators type Parser a b = [a]  [ (b, [a]) ] lijst resultaten i.v.m. ambiguïteit satisfy :: (a  Bool)  Parser a a succeed :: b  Parser a b failp :: Parser a b ( ):: Parser a b  Parser a b  Parser a b ( ):: Parser a (b  c)  Parser a b  Parser a c ( ):: (b  c)  Parser a b  Parser a c

Samenvatting hst. 3 sec. 1-3 ( ) :: Parser a b  Parser a b  Parser a b ( ) :: Parser a (b  c)  Parser a b  Parser a c ( ) :: (b  c)  Parser a b  Parser a c (p q) xs = p xs ++ q xs (p q) xs = [(f b,zs) | (f,ys)  p xs, (b,zs)  q ys] (f p) xs = [ (f b,ys) | (b,ys)  p xs ] infixl 6 infixl 7 infixr 4

Parser combinatoren voor EBNF X  Y* many :: Parser a b  Parser a [b] many p = p many p epsilon (\b bs  b:bs) (\e  [ ]) je hoeft niet eens de string te benoemen! many p = p many p succeed [ ](:)

Parser combinatoren voor EBNF X  Y + many1 :: Parser a b  Parser a [b] many1 p = p many p (:) nooit leeg naam :: Parser Char String naam = many1 (satisfy isAlpha) getal :: Parser Char Int getal = many (satisfy isDigit) foldl f 0 where f n c = 10*n + ord c – ord ‘0’

Parser combinatoren voor EBNF X  Y ? option :: Parser a b  Parser a b option p = p epsilon (\x  d)  b default-waarde option’ :: Parser a b  Parser a [b] option’’ :: Parser a b  Parser a (Maybe b) succeed d d

Parser combinatoren voor EEEEEBNF X  ( Y ) pack :: Parser a o  Parser a b  Parser a s  Parser a b pack p q r = p q r (\o b s  b) gehaakt p = pack (symbol ‘(’) p (symbol ‘)’) geblokt p = pack (symbol ‘[’) p (symbol ‘]’) gepakt p = pack (token “begin”) p (token “end”)

Parser combinatoren voor EEEEEBNF X  ABC many:: Parser a b  Parser a [b] sequence:: [ Parser a b ]  Parser a [b] sequence [ ]= sequence (p:ps)= succeed [ ] (:) p sequence ps sequence = foldr f (succeed []) where f p r = (:) p r

Parser combinatoren voor EEEEEBNF X  A|B|C choice :: [ Parser a b ]  Parser a b choice= foldr ( ) fail

Parser combinatoren voor EEEEEBNF X  B;B;B listOf:: Parser a b  Parser a s  Parser a [b] listOf p s = p many ( s p ) separator (\s b  b) (:)

Parser combinatoren voor EEEEEBNF XB+B+BXB+B+B chainr :: Parser a b  Parser a (b  b  b)  Parser a b chainr pe po = many ( pe po ) pe operator (\e o  (e`o`)) (\fs x  foldr apply x fs) A + B + C + D((A+). (B+). (C+)) D

Parser combinatoren voor EEEEEBNF XB+B+BXB+B+B chainl :: Parser a b  Parser a (b  b  b)  Parser a b chainl pe po = pe many ( po pe ) operator (\o e  (`o`e)) (\x fs  foldl ylppa x fs) A + B + C + D((+D). (+C). (+B)) A

Abstracte syntax voor Expressies data Expr =ConInt |VarString |FunString [Expr] |Expr :+: Expr |Expr :–: Expr |Expr :*: Expr |Expr :/: Expr

Parser voor Expressies (met prioriteiten) expr= chainr term (symbol ‘+’) term= chainr fact (symbol ‘*’) fact= getal gehaakt expr (\o  (:+:)) (\o  (:*:)) Con ( (\o  (:–:)) (symbol ‘–’) ) ( (\o  (:/:)) (symbol ‘/’) ) Var naam Fun naam gehaakt (listOf expr (symbol ‘,’) ) chainl is nu beter

Parser voor Expressies (principe) expr= chainr term(… (:+:)…‘+’ … … (:–:)…‘–’ … ) term= chainr fact(… (:*:)…‘*’ … … (:/:)…‘/’ … ) fact= basis gehaakt expr gen ops next = chainr next ( choice …ops… )

Parser voor Expressies (veel prioriteiten) expr= gen ops1 term1 term1= gen ops2 term2 term2= gen ops3 term3 term3= gen ops4 term4 term4= gen ops5 fact fact= basis gehaakt expr expr = foldr gen fact [ops1,ops2,ops3,ops4,ops5] gen ops next = chainr next ( choice …ops… )