parboiled2 – A Macro-Based PEG Parser Generator for Scala 2.10.3+ Доклад (https://www.youtube.com/watch?v=kZto4nWVlmA) от 29 мая для Moscow Scala Group (http://www.meetup.com/Scala-Moscow/events/180007162/)

1. parboiled2генерируемые макросами генераторы PEG-парсеров
Александр Мыльцев / /github linkedin.com/in/alexandermyltsev
презентация

2. задача парсинга
вход: строка, поток байт, ...
выход: обладает структурой (да/нет), структура
пример
1+2*3—арифметическоевыражение:даилинет?—да
1+2*3—структура?—Plus(1,Mul(2,3))

3. регулярные выражения
нельзя: рекурсивные структуры
1. калькулятор
2. json
3. ...

4. рекурсивный нисходящий парсер:
C/C++
staticintlex_scan_number(lex_t*lex,intc,json_error_t*error)
{
constchar*saved_text;
char*end;
doubledoubleval;
lex->token=TOKEN_INVALID;
if(c=='-')
c=lex_get_save(lex,error);
if(c=='0'){
c=lex_get_save(lex,error);
if(l_isdigit(c)){
lex_unget_unsave(lex,c);
gotoout;
}
}
elseif(l_isdigit(c)){
c=lex_get_save(lex,error);
while(l_isdigit(c))
c=lex_get_save(lex,error);
}
else{
lex_unget_unsave(lex,c);
gotoout;
}
if(c!='.'&&c!='E'&&c!='e'){
json_int_tintval;
lex_unget_unsave(lex,c);
saved_text=strbuffer_value(&lex->saved_text);
https://github.com/akheron/jansson/blob/master/src/load.c

5. рекурсивный нисходящий парсер:
JavaScript
number=function(){
//Parseanumbervalue.
varnumber,
string='';
if(ch==='-'){
string='-';
next('-');
}
while(ch>='0'&&ch<='9'){
string+=ch;
next();
}
if(ch==='.'){
string+='.';
while(next()&&ch>='0'&&ch<='9'){
string+=ch;
}
}
if(ch==='e'||ch==='E'){
string+=ch;
next();
if(ch==='-'||ch==='+'){
string+=ch;
next();
}
while(ch>='0'&&ch<='9'){
string+=ch;
next();
}
}
number=+string;
https://github.com/douglascrockford/JSON-js/blob/master/json_parse.js

6. рекурсивный нисходящий парсер
плюсы
1. код на одном языке
2. одна среда разработки
3. высокая производительность
минусы
1. нет предметно-ориентиррованного языка
2. низкоуровневое кодирование

7. внутренний язык и среда разработки
генерация java-файлов
подключение файлов к проекту
ANTLR3
grammarSimpleCalc;
add:NUMBERPLUSNUMBER;
NUMBER :('0'..'9')+;
PLUS :'+';
javaorg.antlr.ToolSimpleCalc.g

8. ANTLR3
плюсы
1. предметно-ориентированный язык
2. высокая производительность
минусы
1. новый язык, другая среда
2. генерация и подключение файлов

9. комбинаторы парсеров
Haskell Parsec
Scala Combinator Parsers
FParsec

10. комбинаторы парсеров
плюсы
1. программа на исходном языке
2. файлы в исходном проекте
3. исходная среда разработки
4. типизация парсеров
5. близкая к БНФ форма записи
// Expr ::=Term {'+' Term |'-' Term}
defexpr =term~rep("+"~term |"-"~term)
// Term ::= Factor {'*' Factor|'/' Factor}
defterm = factor~rep("*"~factor|"/"~factor)
// Factor ::=Number|'(' Expr ')'
deffactor =number|"("~expr~")"
минусы
1. интерпретатор
2. временные объекты
3. низкая производительность

11. генератор парсеров
1. на одном языке в одной среде разработки
2. типизированный DSL
3. компиляция, а не интерпритация

12. parboiled2
PEG — грамматика, разбирающая выражение
типизированный DSL
компиляция правил

13. rule, ch, str
реализация класса `Parser`
правила грамматики внутри метода rule { }
classSampleParser(valinput:ParserInput)extendsParser{
defAbc=rule{"abc"}
defCh =rule{'7'}
defNum=rule{42}//ошибкакомпиляции
}

14. a ~ b, a | b
classSampleParser(valinput:ParserInput)extendsParser{
defr1=rule{"a"~"b"}//"ab"
defr2=rule{"a"|"b"}//{"a","b"}
defr3=rule{"a"~("b"|"c")}//{"ab","ac"}
defr4=rule{"ab"|"a"}
}

15. zeroOrMore, oneOrMore
classSampleParser(valinput:ParserInput)extendsParser{
defr1=rule{zeroOrMore("a")}//{"","a","aa","aaa",...}
defr2=rule{oneOrMore("a")} //{"a","aa","aaa",...}
}

16. парсер арифметических
выражений
classCalculatorParser(valinput:ParserInput)extendsParser{
defInputLine=rule{Expression~EOI}
//РекурсивныйвызоввParens,поэтомунужентип
defExpression:Rule0=rule{Term~zeroOrMore('+'~Term|'-'~Term)}
defTerm =rule{Factor~zeroOrMore('*'~Factor|'/'~Factor)}
defFactor=rule{Number|Parens}
defParens=rule{'('~Expression~')'}
defNumber=rule{oneOrMore(CharPredicate.Digit)}
}

17. арифметическое выражение:
да или нет?
valline=readline()
valcalc=newCalculatorParser(line)
calc.InputLine().run()match{
caseSuccess(_)=>"Yes"
caseFailure(_)=>"No"
}

18. parser actions, value-stack
value-stack — отличие от haskell parsec et al.
classValueStack(initialSize:Int,maxSize:Int)extendsIterable[Any]{
varbuffer=newArray[Any](initialSize)
varsize =0
}
defDigits =rule{oneOrMore("0"|"1"|/*...*/"9")}//oneOrMore("0"-"9")
defFalse =rule{"false"~push(false)}//"false">>>VStk:[false]
defNumberStr=rule{capture(Digits)}//"42">>>VStk:["42"]
defNumber =rule{capture(Digits)~>(_.toInt)}"42">>>//VStk:[42]
defSum =rule{Number~""~Number~>((_:Int)+_)}//"1115">>>VStk:[26]

19. калькулятор
classCalculatorParser(valinput:ParserInput)extendsParser{
defExpression:Rule1[Int]=rule{
Term~zeroOrMore(
'+'~Term~>((_:Int)+_)
|'-'~Term~>((_:Int)-_))
}
defTerm=rule{
Factor~zeroOrMore(
'*'~Factor~>((_:Int)*_)
|'/'~Factor~>((_:Int)/_))
}
}
`~>` может передавать элемент AST в стек
`~>`-обработчик сам может быть парсером

20. типизация правил и value-stack
defInputRule:Rule[HNil,String::HNil]=rule{capture("a")}
classRule[-I<:HList,+O<:HList]
I-типзначениясостека
O-типзначениявстек
typeRuleN[L<:HList]=Rule[HNil,L]
typeRule0=RuleN[HNil]
typeRule1[T]=RuleN[T::HNil]
typeRule2[A,B]=RuleN[A::B::HNil]

21. типизация правил и value-stack
defa: Rule1[String]=rule{capture("a")}
defb: Rule1[String]=rule{capture("7")}
defbi:Rule1[Int] =rule{b~>((_:String).toInt)}

22. типизация правил и value-stack
defc1:Rule2[String,Int]=rule{a~bi}
defc2:Rule2[Int,Int]=rule{bi~push(42)}
defc3:Rule[Int::HNil,Int::HNil]=rule{capture("7")~>((x:Int,y:String)=>x+y.toInt)}

23. компиляция
abstractclassParser{
defrule(r:Rule):Rule=macroParser.ruleImpl
}
objectParser{
defruleImpl(ctx:ParserContext)(r:ctx.Expr[Rule]):ctx.Expr[Rule]=
reify{
OpTree(r.tree).render().splice
}
}

24. компиляция
objectOpTree{
defapply(tree:Tree):OpTree=
r.treematch{//квазицитирования
caseq"$a.this.str($s)"=>LiteralString(s)
caseq"$a.this.ch($ch)"=>LiteralChar(ch)
caseq"$lhs.|($rhs)" =>FirstOf(OpTree(lhs),OpTree(rhs))
caseq"$lhs.~($rhs)" =>Sequence(OpTree(lhs),OpTree(rhs))
}
}
abstractclassOpTree{
defrender():Expr[Rule]
}
caseclassRule(valmatched:Boolean)

25. LiteralChar
implicitdefch(c:Char):Rule0
rule{ch('a')}
caseq"$a.this.ch($ch)"=>//$a=CalculatorParser,$ch=CharLiteral('a')
caseclassLiteralChar(charTree:Tree)extendsOpTree{
defrender():Expr[Rule]=reify{
valchar=c.Expr[Char](charTree).splice
valp=c.prefix.splice//Currentparser
Rule(p.__nextChar()==char)
}
}

26. LiteralString
implicitdefstr(c:String):Rule0
rule{str("abc")}
caseq"$a.this.str($s)"=>//$a=CalculatorParser,$s=StringLiteral("abc")
caseclassLiteralString(s:Tree)extendsOpTree{
defrender():Expr[Rule]=c.Expr[Rule](q`
valp=${c.prefix}//Currentparser
varix=0
while(ix<$s.length&&$s.charAt(ix)==p.__nextChar()){
ix+=1
}
Rule(ix==$s.length)
`)

27. FirstOf: a | b
//caseq"$lhs.|($rhs)"=>
caseclassFirstOf(charTree:Tree)extendsOpTree{
defrender():Expr[Rule]=c.Expr[Rule](q`
valmark=p.__cursor
if(${OpTree(lhs).render()}.matched){
Rule(true)
}else{
p.__cursor=mark
${OpTree(rhs).render()}
}
`)
}

28. Sequence: a ~ b
//caseq"$lhs.~($rhs)"=>
caseclassFirstOf(charTree:Tree)extendsOpTree{
defrender():Expr[Rule]=c.Expr[Rule](q`
Rule(${OpTree(lhs).render()}.matched&&${OpTree(rhs).render()}.matched)
`)
}

29. parboiled2.org
oneOrMore
zeroOrMore
~>
...

30. использование
json-парсер в ~100 быстрее Scala Parsers, в ~10 parboiled1
typesafe, spray.io, spray-json

31. parboiled2.org
linkedin.com/in/alexandermyltsev
вопросы