Mastering Grammars with PetitParser
•
2 likes•1,371 views
PetitParser is a dynamic parser framework combining ideas from scannerless parsing, parser combinators, parsing expression grammars and packrat parsers. In this hands-on session we learn how to build simple parsers and how to model, test, compose and reuse complex grammars. Additionally, we will look at some tools and the reflective facilities provided by the PetitParser framework. Basic knowledge of the Smalltalk programming language is a requirement. Bring your laptop to reproduce the examples and solve some simple tasks.
Recommended
More Related Content
What's hot
What's hot (20)
Viewers also liked
Viewers also liked (8)
Similar to Mastering Grammars with PetitParser
Similar to Mastering Grammars with PetitParser (20)
More from Lukas Renggli
More from Lukas Renggli (12)
Recently uploaded
Recently uploaded (20)
Mastering Grammars with PetitParser
- 1. Mastering Grammars with Lukas Renggli
- 3. Agenda 1. PetitParser in a Nutshell 2. Combinatorial Parsing 3. Complex Grammars 4. Advanced Use
- 5. ID ::= letter { letter | digit } ; a..z a..z 0..9
- 6. ID ::= letter { letter | digit } ; sequence letter many choice letter digit
- 7. id := #letter asParser , (#letter asParser / #digit asParser) star sequence letter many choice letter digit
- 8. id parse: 'yeah'. " -‐-‐> #($y #($e $a $h)) " id parse: 'f12'. " -‐-‐> #($f #($1 $2)) " id parse: '123'. " -‐-‐> letter expected at 0 "
- 9. Example 1 ‣ Test the identifier parser ‣ Inspect the parser object ‣ Create and test an integer parser
- 11. Parser Terminals $a asParser letter ‘a’ 'abc' asParser string ‘abc’ These factory methods are defined in PPPredicateObjectParser class #any asParser any character #digit asParser the digits 0..9 #letter asParser the letters a..z and A..Z nil asParser the empty parser
- 12. Parser Operators p1 , p2 sequence p1 / p2 ordered choice p star zero-or-more (0..*) p plus one-or-more (1..*) p optional zero-or-one (0..1) see the operations p1 separatedBy: p2 protocols in PPParser p1 delimitedBy: p2 for more operators
- 13. Parser Predicates p and conjunction (non-consuming look-ahead) p not negation (non-consuming look-ahead) p end end of input
- 14. Parser Actions p ==> [ :arg | ] transformation p flatten create string p token create token p trim trim whitespaces see the operations-mapping protocol in PPParser for more actions
- 15. term ::= prod "+" term | prod ; prod ::= prim "*" prod | prim ; prim ::= "(" term ")" | number ; number ::= "0" .. "9" ;
- 16. number := #digit asParser plus flatten trim ==> [ :string | string asNumber ]. term := PPUnresolvedParser new. prod := PPUnresolvedParser new. prim := PPUnresolvedParser new. term def: (prod , $+ asParser trim , term ==> [ :nodes | nodes first + nodes last ]) / prod. prod def: (prim , $* asParser trim , prod ==> [ :nodes | nodes first * nodes last ]) / prim. prim def: ($( asParser trim , term , $) asParser trim ==> [ :nodes | nodes second ]) / number. start := term end.
- 17. start parse: '1 + 2 * 3'. " -‐-‐> 7 " start parse: '(1 + 2) * 3'. " -‐-‐> 9 "
- 18. Example 2 ‣ Add support for negative numbers ‣ Add support for floating point numbers ‣ Add support for subtraction & division
- 19. Complex Grammars
- 21. to qu ick wr ite PetitParser Scripts embe d in Smal to ltalk
- 22. to qu ick d iffic ult wr ite to reu se PetitParser Scripts embe messy hard d in to if large Smal to tes t ltalk
- 25. One Method per Production PPCompositeParser start ExpressionGrammar start start term ^ term end prod ...
- 26. One Instance Variable per Production PPCompositeParser start ExpressionGrammar start term term ^ (prod , $+ asParser t prod / prod ...
- 27. Refer to Productions by Inst-Var Reference PPCompositeParser start ExpressionGrammar start term prod prod ^ (prim , $* asParser t ... / prim
- 28. res t is PPCompositeParser mag ic start ExpressionGrammar start term prod ...
- 30. Example 3 ‣ Implement an expression grammar ‣ Implement an expression evaluator ‣ Implement an expression pretty printer
- 31. Advanced Use
- 32. does not just work on Strings
- 33. Matching p matches: 'abc'. p matchesIn: 'abc'. p matchesIn: 'abc' do: [ :each | ]. p matchingRangesIn: 'abc'. p matchingRangesIn: 'abc' do: [ :interval | ].
- 34. World ➔ Tools ➔ PetitParser GUI PPBrowser open
- 35. Reflection p allParser. p allParserDo: [ :each | ]. p firstSet. p followSet. p cycleSet.
- 36. Transformations p replace: p1 with: p2. p transform: [ :parser | ]. Like #collect: on Collection, but transforms the whole grammar graph.
- 37. Pattern Searching A placeholder matching any parser found := PPSearcher new matches: PPPattern any star plus do: [ :parser :answer | parser ]; execute: p initialAnswer: nil Grammar to be searched
- 38. Pattern Rewriting Same pattern used in search and replace. pattern := PPPattern any. rewritten := PPRewriter new replace: pattern star plus with: pattern star; execute: p Grammar to be rewritten
- 39. Grammar Optimization fast := slow optimize Many behavior preserving rewrite rules applied for you.
- 40. 3000000 2000000 chars/sec 1000000 0 LALR PetitParser Hand-Written Old VM Cog VM