JParser (9) Abstract Syntax Tree 프로세서

Expr = Term WS '+' WS Expr
     | Term
Term = Factor WS '*' WS Term
     | Factor
Factor = '0-9'
     | '(' WS Expr WS ')'
WS = ' '*

Expr: Expr = Term WS '+' WS Expr {Add(lhs=$0, rhs=$4)}
           | Term
Term: Term = Factor WS '*' WS Term {Multiply(lhs=$0, rhs=$4)}
           | Factor
Factor: Factor = '0-9' {Number(value=str($0))}
           | '(' WS Expr WS ')' {Paren(body=$2)}
WS = ' '*

Expr: Expr = Term WS '+' WS Expr {BinOp(op:%Op=%Add, lhs=$0, rhs=$4)}
           | Term
Term: Term = Factor WS '*' WS Term {BinOp(op=%Mul, lhs=$0, rhs=$4)}
           | Factor
Factor: Factor = '0-9' {Number(value=str($0))}
           | '(' WS Expr WS ')' {Paren(body=$2)}
WS = ' '*

Grammar = WS Def (WSNL Def)* WS {Grammar(defs=[$1] + $2)}
Def: Def = Rule | TypeDef

Rule = LHS WS '=' WS (RHS (WS '|' WS RHS)* {[$0] + $1}) {Rule(lhs=$0, rhs=$4)}
  // $4는 괄호 안 시퀀스의 마지막 값인 [$0] + $1 을 가리킨다. $4{[$0] + $1} 라고 바꿔 쓸 수 있다.
LHS = Nonterminal (WS ':' WS TypeDesc)? {LHS(name=$0, typeDesc=$1)}
  // LHS의 typeDesc는 TypeDesc 심볼의 타입(TypeDesc 클래스)의 nullable 타입이다.
RHS = Sequence
Sequence = Elem (WS Elem)* {Sequence<Symbol>(seq=[$0] + $1)}
  // Sequence<Symbol>이라고 쓰면 Sequence 타입이 Symbol 타입을 상속받아야 함을 명시한 것
  // $0은 Elem이고 $1은 Elem의 리스트 타입이므로 둘을 이어 붙이려면 [$0] + $1 라고 써야 한다.
Elem: Elem = Symbol | Processor


// Symbol
Symbol: Symbol = BinSymbol
BinSymbol: BinSymbol = BinSymbol WS '&' WS PreUnSymbol {JoinSymbol(body=$0, join=$4)}
  | BinSymbol WS '-' WS PreUnSymbol {ExceptSymbol(body=$0, except=$4)}
  | PreUnSymbol
PreUnSymbol: PreUnSymbol = '^' WS PreUnSymbol {FollowedBy(followedBy=$2)}
  | '!' WS PreUnSymbol {NotFollowedBy(notFollowedBy=$2)}
  | PostUnSymbol
PostUnSymbol: PostUnSymbol = PostUnSymbol WS '?' {Optional(body=$0)}
  | PostUnSymbol WS '*' {RepeatFromZero(body=$0)}
  | PostUnSymbol WS '+' {RepeatFromOne(body=$0)}
  | AtomSymbol
AtomSymbol: AtomSymbol = Terminal
  | TerminalChoice
  | StringSymbol
  | Nonterminal
  | '(' WS InPlaceChoices WS ')' $2  // $2 대신 {$2}라고 써도 같은 의미이다.
  | Longest
  | EmptySequence
Terminal: Terminal = '\'' TerminalChar '\'' $1
  | '.' {AnyTerminal()}  // 인자를 받지 않는 클래스도 있을 수 있다
TerminalChoice: TerminalChoice = '\'' TerminalChoiceElem TerminalChoiceElem+ '\'' {TerminalChoice(choices=[$1] + $2)}
  | '\'' TerminalChoiceRange '\'' {TerminalChoice(choices=[$1])}
  // 클래스의 멤버 변수 이름과 순서는 한 번만 정의하면 된다.
  // 즉, 위에서 TerminalChoice가 choices라는 하나의 파라메터를 받는 것을 알 수 있으니 두번째는 TerminalChoice([$1]) 라고만 써도 된다.
TerminalChoiceElem: TerminalChoiceElem = TerminalChoiceChar
  | TerminalChoiceRange
TerminalChoiceRange = TerminalChoiceChar '-' TerminalChoiceChar {TerminalChoiceRange(start=$0, end=$2)}
StringSymbol = '"' StringChar* '"' {StringSymbol(value=$1)}
Nonterminal = NonterminalName {Nonterminal(name=$0)}
InPlaceChoices = Sequence (WS '|' WS Sequence)* {InPlaceChoices(choices=[$0] + $1)}
Longest = '<' WS InPlaceChoices WS '>' {Longest(choices=$2)}
EmptySequence = '#' {EmptySeq()}

TerminalChar: TerminalChar = .-'\\' {CharAsIs(value=$0)}
  | '\\' '\'\\bnrt' {CharEscaped(escapeCode=$1)}
  | UnicodeChar
TerminalChoiceChar: TerminalChoiceChar = .-'\'\-\\' {CharAsIs(value=$0)}
  | '\\' '\'\-\\bnrt' {CharEscaped(escapeCode=$1)}
  | UnicodeChar
StringChar: StringChar = .-'"\\' {CharAsIs(value=$0)}
  | '\\' '"\\bnrt' {CharEscaped(escapeCode=$1)}
  | UnicodeChar
UnicodeChar = '\\' 'u' '0-9A-Fa-f' '0-9A-Fa-f' '0-9A-Fa-f' '0-9A-Fa-f' {CharUnicode(code=[$2, $3, $4, $5])}


// Processor
Processor: Processor = Ref
  | PExprBlock

Ref: Ref = ValRef | RawRef
ValRef = '$' CondSymPath? RefIdx {ValRef(idx=$2, condSymPath=$1)}
CondSymPath: [%CondSymDir{BODY, COND}] = ('<' {%BODY} | '>' {%COND})+
  // %CondSymDir{BODY, COND} 라고 쓰면 CondSymDir이란 enum 타입의 멤버 값이 BODY와 COND가 있다는 의미이다.
  // enum의 멤버 값을 이렇게 명시하면 명시된 값만 사용할 수 있다. 문법 정의의 다른 곳에서 명시되지 않은 값을 쓰려고 할 때 오류가 발생한다.
RawRef = "\\$" CondSymPath? RefIdx {RawRef(idx=$2, condSymPath=$1)}

PExprBlock = '{' WS PExpr WS '}' {ProcessorBlock(body=$2)}
PExpr: PExpr = TernaryExpr WS ':' WS TypeDesc {TypedPExpr(body=$0, typ=$4)}
  | TernaryExpr
TernaryExpr: TernaryExpr = BoolOrExpr WS '?' WS <TernaryExpr> WS ':' WS <TernaryExpr> {TernaryOp(cond=$0, ifTrue=$4, ifFalse=$8)}
  | BoolOrExpr
BoolOrExpr: BoolOrExpr = BoolAndExpr WS "&&" WS BoolOrExpr {BinOp(op=%Op.AND, lhs=$0, rhs=$4)}
  | BoolAndExpr
BoolAndExpr: BoolAndExpr = BoolEqExpr WS "||" WS BoolAndExpr {BinOp(op=%Op.OR, lhs=$0, rhs=$4)}
  | BoolEqExpr
BoolEqExpr: BoolEqExpr = ElvisExpr WS ("==" {%Op.EQ} | "!=" {%Op.NE}) WS BoolEqExpr {BinOp(op=$2, lhs=$0, rhs=$4)}
  | ElvisExpr
ElvisExpr: ElvisExpr = AdditiveExpr WS "?:" WS ElvisExpr {ElvisOp(value=$0, ifNull=$4)}
  | AdditiveExpr
AdditiveExpr: AdditiveExpr = PrefixNotExpr WS ('+' {%Op.ADD}) WS AdditiveExpr {BinOp(op=$2, lhs=$0, rhs=$4)}
  | PrefixNotExpr
PrefixNotExpr: PrefixNotExpr = '!' WS PrefixNotExpr {PrefixOp(op=%PreOp.NOT, expr=$2)}
  | Atom
Atom: Atom = Ref
  | BindExpr
  | NamedConstructExpr
  | FuncCallOrConstructExpr
  | ArrayExpr
  | Literal
  | EnumValue
  | '(' WS PExpr WS ')' {ExprParen(body=$2)}

BindExpr = ValRef BinderExpr {BindExpr(ctx=$0, binder=$1)}
BinderExpr: BinderExpr = Ref
  | BindExpr
  | PExprBlock
NamedConstructExpr = TypeName (WS SuperTypes)? WS NamedConstructParams {NamedConstructExpr(typeName=$0, params=$3, supers=$1)}
NamedConstructParams = '(' WS (NamedParam (WS ',' WS NamedParam)* WS {[$0] + $1}) ')' $2
NamedParam = ParamName (WS ':' WS TypeDesc)? WS '=' WS PExpr {NamedParam(name=$0, typeDesc=$1, expr=$5)}
FuncCallOrConstructExpr = TypeOrFuncName WS CallParams {FuncCallOrConstructExpr(funcName=$0, params=$2)}
CallParams: [PExpr] = '(' WS (PExpr (WS ',' WS PExpr)* WS {[$0] + $1})? ')' {$2 ?: []}
  // $2는 PExpr 리스트의 nullable 타입이다. elvis 연산자로 $2가 null이면 빈 리스트를 반환하도록 하였다.
ArrayExpr = '[' WS (PExpr (WS ',' WS PExpr)* WS)? ']' {ArrayExpr(elems: [PExpr]=$2{[$0] + $1} ?: [])}
Literal: Literal = "null" {NullLiteral()}
  | ("true" {true} | "false" {false}) {BoolLiteral(value=$0)}
  | '\'' CharChar '\'' {CharLiteral(value=$1)}
  | '"' StrChar* '"' {StrLiteral(value=$1)}
EnumValue: AbstractEnumValue = <CanonicalEnumValue | ShortenedEnumValue>
CanonicalEnumValue = EnumTypeName '.' EnumValueName {CanonicalEnumValue(enumName=$0, valueName=$2)}
ShortenedEnumValue = '%' EnumValueName {ShortenedEnumValue(valueName=$1)}
  // ShortenedEnumValue는 값이 enum type이 무엇인지 확실할 때만 사용할 수 있다.


// TypeDef
TypeDef: TypeDef = ClassDef
  | SuperDef
  | EnumTypeDef
ClassDef: ClassDef = TypeName WS SuperTypes {AbstractClassDef(name=$0, supers=$2)}
  | TypeName WS ClassParamsDef {ConcreteClassDef(name=$0, supers: [TypeName]?=null, params=$2)}
  | TypeName WS SuperTypes WS ClassParamsDef {ConcreteClassDef(name=$0, supers=$2, params=$4)}
SuperTypes: [TypeName] = '<' WS (TypeName (WS ',' WS TypeName)* WS {[$0] + $1})? '>' {$2 ?: []}
ClassParamsDef: [ClassParamDef] = '(' WS (ClassParamDef (WS ',' WS ClassParamDef)* WS {[$0] + $1})? WS ')' {$2 ?: []}
ClassParamDef = ParamName (WS ':' WS TypeDesc)? {ClassParamDef(name=$0, typeDesc=$1)}

SuperDef = TypeName (WS SuperTypes)? WS '{' (WS SubTypes)? WS '}' {SuperDef(typeName=$0, subs=$4, supers=$1)}
SubTypes = SubType (WS ',' WS SubType)* {[$0] + $1}
SubType: SubType = TypeName | ClassDef | SuperDef

EnumTypeDef = EnumTypeName WS '{' WS (Id (WS ',' WS Id)* {[$0] + $1}) WS '}' {EnumTypeDef(name=$0, values=$4)}


// TypeDesc
TypeDesc = NonNullTypeDesc (WS '?')? {TypeDesc(typ=$0, optional=ispresent($1))}
NonNullTypeDesc: NonNullTypeDesc = TypeName
  | '[' WS TypeDesc WS ']' {ArrayTypeDesc(elemType=$2)}
  | ValueType
  | AnyType
  | EnumTypeName
  | TypeDef

ValueType: ValueType = "boolean" {BooleanType()}
  | "char" {CharType()}
  | "string" {StringType()}
AnyType = "any" {AnyType()}
EnumTypeName = '%' Id {EnumTypeName(name=str($1))}


// Common
TypeName = IdNoKeyword {TypeName(name=$0)}
  | '`' Id '`' {TypeName(name=$1)}
NonterminalName = IdNoKeyword {NonterminalName(name=$0)}
  | '`' Id '`' {NonterminalName(name=$1)}
TypeOrFuncName = IdNoKeyword {TypeOrFuncName(name=$0)}
  | '`' Id '`' {TypeOrFuncName(name=$1)}
ParamName = IdNoKeyword {ParamName(name=$0)}
  | '`' Id '`' {ParamName(name=$1)}
EnumValueName = Id {EnumValueName(name=$0)}
Keyword: %KeyWord = "boolean" {%BOOLEAN}
  | "char" {%CHAR}
  | "string" {%STRING}
  | "true" {%TRUE}
  | "false" {%FALSE}
  | "null" {%NULL}
  // Keyword가 %Keyword 타입이므로 Keyword의 RHS에 나오는 값들은 모두 %Keyword 타입임을 알 수 있다.
StrChar = StringChar
CharChar = TerminalChar

RefIdx = <'0' | '1-9' '0-9'*> {str(\$0)}
  // \$0라고 쓰면 $0의 parse tree를 있는대로 반환한다.
  // 여기서 \$0 대신 $0라고 쓰면 '1-9' '0-9'*에서 '0-9'*만 반영될 것이다.
Id = <'a-zA-Z_' 'a-zA-Z0-9_'*> {str(\$0)}
IdNoKeyword = Id-Keyword {str(\$0)}
WS = (' \n\r\t' | Comment)*
WSNL = <(' \r\t' | Comment)* '\n' WS>
Comment = LineComment | BlockComment
LineComment = "//" (.-'\n')* (EOF | '\n')
BlockComment = "/*" ((. !"*/")* .)? "*/"
EOF = !.
  // !.는 파일의 마지막을 의미한다.
  // .은 모든 글자에 매치되므로, !.가 나오면 다음에 어떤 글자가 와도 매치될 수 없기 때문이다.